diff options
Diffstat (limited to 'test/std/containers/unord/unord.map')
42 files changed, 488 insertions, 427 deletions
diff --git a/test/std/containers/unord/unord.map/bucket.pass.cpp b/test/std/containers/unord/unord.map/bucket.pass.cpp index 1abb58070afd..8931fdf642ff 100644 --- a/test/std/containers/unord/unord.map/bucket.pass.cpp +++ b/test/std/containers/unord/unord.map/bucket.pass.cpp @@ -23,6 +23,7 @@ #include <string> #include <cassert> +#include "test_macros.h" #include "min_allocator.h" int main() @@ -43,7 +44,7 @@ int main() size_t bc = c.bucket_count(); assert(bc >= 5); for (size_t i = 0; i < 13; ++i) - assert(c.bucket(i) == i % bc); + LIBCPP_ASSERT(c.bucket(i) == i % bc); } #if TEST_STD_VER >= 11 { @@ -63,7 +64,7 @@ int main() size_t bc = c.bucket_count(); assert(bc >= 5); for (size_t i = 0; i < 13; ++i) - assert(c.bucket(i) == i % bc); + LIBCPP_ASSERT(c.bucket(i) == i % bc); } #endif #if _LIBCPP_DEBUG_LEVEL >= 1 diff --git a/test/std/containers/unord/unord.map/bucket_count.pass.cpp b/test/std/containers/unord/unord.map/bucket_count.pass.cpp index bc3733742600..9ab8bfd19382 100644 --- a/test/std/containers/unord/unord.map/bucket_count.pass.cpp +++ b/test/std/containers/unord/unord.map/bucket_count.pass.cpp @@ -27,7 +27,7 @@ int main() { typedef std::unordered_map<int, std::string> C; const C c; - assert(c.bucket_count() == 0); + LIBCPP_ASSERT(c.bucket_count() == 0); } { typedef std::unordered_map<int, std::string> C; @@ -44,14 +44,14 @@ int main() P(80, "eighty"), }; const C c(std::begin(a), std::end(a)); - assert(c.bucket_count() >= 11); + assert(c.bucket_count() >= 8); } #if TEST_STD_VER >= 11 { typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, std::string>>> C; const C c; - assert(c.bucket_count() == 0); + LIBCPP_ASSERT(c.bucket_count() == 0); } { typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, @@ -69,7 +69,7 @@ int main() P(80, "eighty"), }; const C c(std::begin(a), std::end(a)); - assert(c.bucket_count() >= 11); + assert(c.bucket_count() >= 8); } #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 index 4344508b7334..af25de4db769 100644 --- a/test/std/containers/unord/unord.map/bucket_size.pass.cpp +++ b/test/std/containers/unord/unord.map/bucket_size.pass.cpp @@ -23,6 +23,7 @@ #include <string> #include <cassert> +#include "test_macros.h" #include "min_allocator.h" int main() @@ -41,11 +42,11 @@ int main() }; 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); + LIBCPP_ASSERT(c.bucket_size(0) == 0); + LIBCPP_ASSERT(c.bucket_size(1) == 1); + LIBCPP_ASSERT(c.bucket_size(2) == 1); + LIBCPP_ASSERT(c.bucket_size(3) == 1); + LIBCPP_ASSERT(c.bucket_size(4) == 1); } #if TEST_STD_VER >= 11 { @@ -63,11 +64,11 @@ int main() }; 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); + LIBCPP_ASSERT(c.bucket_size(0) == 0); + LIBCPP_ASSERT(c.bucket_size(1) == 1); + LIBCPP_ASSERT(c.bucket_size(2) == 1); + LIBCPP_ASSERT(c.bucket_size(3) == 1); + LIBCPP_ASSERT(c.bucket_size(4) == 1); } #endif #if _LIBCPP_DEBUG_LEVEL >= 1 diff --git a/test/std/containers/unord/unord.map/iterators.pass.cpp b/test/std/containers/unord/unord.map/iterators.pass.cpp index 31f4254ea3f8..f99adb52b3f2 100644 --- a/test/std/containers/unord/unord.map/iterators.pass.cpp +++ b/test/std/containers/unord/unord.map/iterators.pass.cpp @@ -23,7 +23,9 @@ #include <unordered_map> #include <string> #include <cassert> +#include <cstddef> +#include "test_macros.h" #include "min_allocator.h" int main() @@ -43,8 +45,8 @@ int main() 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()); + assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); C::iterator i; } { @@ -62,8 +64,8 @@ int main() 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()); + assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); C::const_iterator i; } #if TEST_STD_VER >= 11 @@ -83,8 +85,8 @@ int main() 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()); + assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); C::iterator i; } { @@ -103,12 +105,12 @@ int main() 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()); + assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); C::const_iterator i; } #endif -#if _LIBCPP_STD_VER > 11 +#if TEST_STD_VER > 11 { // N3644 testing typedef std::unordered_map<int,double> C; C::iterator ii1{}, ii2{}; diff --git a/test/std/containers/unord/unord.map/max_size.pass.cpp b/test/std/containers/unord/unord.map/max_size.pass.cpp index 9c1ca18c3054..152741981461 100644 --- a/test/std/containers/unord/unord.map/max_size.pass.cpp +++ b/test/std/containers/unord/unord.map/max_size.pass.cpp @@ -9,28 +9,45 @@ // <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 <limits> +#include <type_traits> +#include <unordered_map> -#include "min_allocator.h" +#include "test_allocator.h" +#include "test_macros.h" int main() { - { - std::unordered_map<int, int> u; - assert(u.max_size() > 0); + typedef std::pair<const int, int> KV; + { + typedef limited_allocator<KV, 10> A; + typedef std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, A> + C; + C c; + assert(c.max_size() <= 10); + LIBCPP_ASSERT(c.max_size() == 10); + } + { + typedef limited_allocator<KV, (size_t)-1> A; + typedef std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, A> + C; + const C::difference_type max_dist = + std::numeric_limits<C::difference_type>::max(); + C c; + assert(c.max_size() <= max_dist); + LIBCPP_ASSERT(c.max_size() == max_dist); } -#if TEST_STD_VER >= 11 { - 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); + typedef std::unordered_map<char, int> C; + const C::difference_type max_dist = + std::numeric_limits<C::difference_type>::max(); + C c; + assert(c.max_size() <= max_dist); + assert(c.max_size() <= alloc_max_size(c.get_allocator())); } -#endif } diff --git a/test/std/containers/unord/unord.map/rehash.pass.cpp b/test/std/containers/unord/unord.map/rehash.pass.cpp index fce751593a5e..58222b7f924d 100644 --- a/test/std/containers/unord/unord.map/rehash.pass.cpp +++ b/test/std/containers/unord/unord.map/rehash.pass.cpp @@ -19,6 +19,7 @@ #include <string> #include <cassert> +#include "test_macros.h" #include "min_allocator.h" template <class C> @@ -56,16 +57,16 @@ int main() assert(c.bucket_count() >= 5); c.rehash(3); rehash_postcondition(c, 3); - assert(c.bucket_count() == 5); + LIBCPP_ASSERT(c.bucket_count() == 5); test(c); c.max_load_factor(2); c.rehash(3); rehash_postcondition(c, 3); - assert(c.bucket_count() == 3); + LIBCPP_ASSERT(c.bucket_count() == 3); test(c); c.rehash(31); rehash_postcondition(c, 31); - assert(c.bucket_count() == 31); + LIBCPP_ASSERT(c.bucket_count() == 31); test(c); } #if TEST_STD_VER >= 11 @@ -87,16 +88,16 @@ int main() assert(c.bucket_count() >= 5); c.rehash(3); rehash_postcondition(c, 3); - assert(c.bucket_count() == 5); + LIBCPP_ASSERT(c.bucket_count() == 5); test(c); c.max_load_factor(2); c.rehash(3); rehash_postcondition(c, 3); - assert(c.bucket_count() == 3); + LIBCPP_ASSERT(c.bucket_count() == 3); test(c); c.rehash(31); rehash_postcondition(c, 31); - assert(c.bucket_count() == 31); + LIBCPP_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 index 5999801a3923..1836c2a41da1 100644 --- a/test/std/containers/unord/unord.map/reserve.pass.cpp +++ b/test/std/containers/unord/unord.map/reserve.pass.cpp @@ -19,6 +19,7 @@ #include <string> #include <cassert> +#include "test_macros.h" #include "min_allocator.h" template <class C> @@ -64,7 +65,7 @@ int main() test(c); assert(c.bucket_count() >= 5); c.reserve(3); - assert(c.bucket_count() == 5); + LIBCPP_ASSERT(c.bucket_count() == 5); test(c); c.max_load_factor(2); c.reserve(3); @@ -92,7 +93,7 @@ int main() test(c); assert(c.bucket_count() >= 5); c.reserve(3); - assert(c.bucket_count() == 5); + LIBCPP_ASSERT(c.bucket_count() == 5); test(c); c.max_load_factor(2); c.reserve(3); diff --git a/test/std/containers/unord/unord.map/swap_member.pass.cpp b/test/std/containers/unord/unord.map/swap_member.pass.cpp index 0f98b66aa401..86a068cd357b 100644 --- a/test/std/containers/unord/unord.map/swap_member.pass.cpp +++ b/test/std/containers/unord/unord.map/swap_member.pass.cpp @@ -18,6 +18,7 @@ #include <unordered_map> #include <string> #include <cassert> +#include <cstddef> #include "../../test_compare.h" #include "../../test_hash.h" @@ -32,27 +33,27 @@ int main() 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; - C c1(0, Hash(1), Compare(1), Alloc(1)); - C c2(0, Hash(2), Compare(2), Alloc(2)); + C c1(0, Hash(1), Compare(1), Alloc(1, 1)); + C c2(0, Hash(2), Compare(2), Alloc(1, 2)); c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() == 0); + LIBCPP_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.get_allocator().get_id() == 1); + assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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.get_allocator().get_id() == 2); + assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -72,12 +73,12 @@ int main() 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)); + C c1(0, Hash(1), Compare(1), Alloc(1, 1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2)); c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -89,18 +90,18 @@ int main() 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.get_allocator().get_id() == 1); + assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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.get_allocator().get_id() == 2); + assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -118,21 +119,21 @@ int main() 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)); + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1)); + C c2(0, Hash(2), Compare(2), Alloc(1, 2)); c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() == 0); + LIBCPP_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.get_allocator().get_id() == 1); + assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -140,9 +141,9 @@ int main() 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.get_allocator().get_id() == 2); + assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -171,12 +172,12 @@ int main() 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)); + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2)); c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -188,12 +189,12 @@ int main() 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.get_allocator().get_id() == 1); + assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -201,9 +202,9 @@ int main() 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.get_allocator().get_id() == 2); + assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } @@ -217,22 +218,22 @@ int main() c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -257,7 +258,7 @@ int main() c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -270,17 +271,17 @@ int main() 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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -303,16 +304,16 @@ int main() c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -321,8 +322,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -356,7 +357,7 @@ int main() c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -369,11 +370,11 @@ int main() 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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -382,8 +383,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } #if TEST_STD_VER >= 11 @@ -397,22 +398,22 @@ int main() c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -437,7 +438,7 @@ int main() c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -450,17 +451,17 @@ int main() 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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -483,16 +484,16 @@ int main() c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -501,8 +502,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -536,7 +537,7 @@ int main() c2.max_load_factor(2); c1.swap(c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -549,11 +550,11 @@ int main() 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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -562,8 +563,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } #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 index 232f2fd4fd59..6caa59728cef 100644 --- 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 @@ -18,6 +18,7 @@ #include <unordered_map> #include <cassert> +#include "test_macros.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" #include "../../../test_hash.h" @@ -34,7 +35,7 @@ int main() NotConstructible> > > C; C c(test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)); - assert(c.bucket_count() == 0); + LIBCPP_ASSERT(c.bucket_count() == 0); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.get_allocator() == @@ -54,7 +55,7 @@ int main() NotConstructible> > > C; C c(min_allocator<std::pair<const NotConstructible, NotConstructible> >{}); - assert(c.bucket_count() == 0); + LIBCPP_ASSERT(c.bucket_count() == 0); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.get_allocator() == @@ -93,7 +94,7 @@ int main() A a(10); C c(2, a); - assert(c.bucket_count() == 2); + LIBCPP_ASSERT(c.bucket_count() == 2); assert(c.hash_function() == HF()); assert(c.key_eq() == Comp()); assert(c.get_allocator() == a); @@ -113,7 +114,7 @@ int main() A a(10); HF hf(12); C c(2, hf, a); - assert(c.bucket_count() == 2); + LIBCPP_ASSERT(c.bucket_count() == 2); assert(c.hash_function() == hf); assert(!(c.hash_function() == HF())); assert(c.key_eq() == Comp()); 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 index ee85750f5c36..b793f0934355 100644 --- 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 @@ -19,7 +19,9 @@ #include <string> #include <cassert> #include <cfloat> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -57,7 +59,7 @@ int main() A(4) ); c = c0; - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -67,8 +69,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } @@ -130,8 +132,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } @@ -166,7 +168,7 @@ int main() A() ); c = c0; - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -176,8 +178,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } 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 index e4da30bb4efd..4d92b3d4c2c5 100644 --- 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 @@ -19,6 +19,7 @@ #include <string> #include <cassert> #include <cfloat> +#include <cstddef> #include "../../../test_compare.h" #include "../../../test_hash.h" @@ -54,8 +55,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } @@ -87,8 +88,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } 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 index fe3eaee4642b..e86d35b0ac8b 100644 --- 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 @@ -19,7 +19,9 @@ #include <string> #include <cassert> #include <cfloat> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -58,7 +60,7 @@ int main() A(4) ); c = std::move(c0); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -68,8 +70,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } @@ -103,7 +105,7 @@ int main() A(10) ); c = std::move(c0); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -113,8 +115,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); @@ -149,7 +151,7 @@ int main() A(4) ); c = std::move(c0); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -159,8 +161,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); @@ -196,7 +198,7 @@ int main() A() ); c = std::move(c0); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -206,8 +208,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp index 417120b9eb0e..7f62a4fedf83 100644 --- a/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp @@ -12,7 +12,7 @@ // <unordered_map> -// Check that std::unordered_map fails to instantiate if the comparison predicate is +// Check that std::unordered_map fails to instantiate if the comparison predicate is // not copy-constructible. This is LWG issue 2436 #include <unordered_map> 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 index 0590d12818b3..0b1d460ef74b 100644 --- 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 @@ -20,7 +20,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -51,7 +53,7 @@ int main() test_allocator<std::pair<const int, std::string> >(10) ); C c = c0; - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -62,12 +64,12 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } -#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE +#if TEST_STD_VER >= 11 { typedef std::unordered_map<int, std::string, test_hash<std::hash<int> >, @@ -91,7 +93,7 @@ int main() other_allocator<std::pair<const int, std::string> >(10) ); C c = c0; - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -102,13 +104,11 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } -#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE -#if TEST_STD_VER >= 11 { typedef std::unordered_map<int, std::string, test_hash<std::hash<int> >, @@ -132,7 +132,7 @@ int main() min_allocator<std::pair<const int, std::string> >() ); C c = c0; - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -143,8 +143,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } 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 index 3c0be631386c..cf83074ae170 100644 --- 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 @@ -20,7 +20,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -51,7 +53,7 @@ int main() 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); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -62,8 +64,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -91,7 +93,7 @@ int main() min_allocator<std::pair<const int, std::string> >() ); C c(c0, min_allocator<std::pair<const int, std::string> >()); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -102,8 +104,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -141,8 +143,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } 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 index ad7f3a914dcb..04d172e4ddfe 100644 --- 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 @@ -18,6 +18,7 @@ #include <unordered_map> #include <cassert> +#include "test_macros.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" #include "../../../test_hash.h" @@ -34,7 +35,7 @@ int main() NotConstructible> > > C; C c; - assert(c.bucket_count() == 0); + LIBCPP_ASSERT(c.bucket_count() == 0); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.get_allocator() == @@ -54,7 +55,7 @@ int main() NotConstructible> > > C; C c; - assert(c.bucket_count() == 0); + LIBCPP_ASSERT(c.bucket_count() == 0); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.get_allocator() == @@ -100,7 +101,7 @@ int main() } { std::unordered_map<int, int> c = {}; - assert(c.bucket_count() == 0); + LIBCPP_ASSERT(c.bucket_count() == 0); assert(c.size() == 0); assert(c.empty()); assert(std::distance(c.begin(), c.end()) == 0); 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 index 3585fe7b881a..4fb10afd4e59 100644 --- 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 @@ -16,6 +16,7 @@ #include <unordered_map> #include <cassert> +#include "test_macros.h" #include "MoveOnly.h" #include "test_allocator.h" @@ -54,11 +55,11 @@ int main() } { typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; - static_assert(!std::is_nothrow_destructible<C>::value, ""); + LIBCPP_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, ""); + LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); } } diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp index 709b56de2453..2525c4444ffb 100644 --- a/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp +++ b/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp @@ -12,7 +12,7 @@ // <unordered_map> -// Check that std::unordered_map fails to instantiate if the hash function is +// Check that std::unordered_map fails to instantiate if the hash function is // not copy-constructible. This is mentioned in LWG issue 2436 #include <unordered_map> 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 index e980b68b57c1..bebab0375d86 100644 --- 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 @@ -19,7 +19,9 @@ #include <string> #include <cassert> #include <cfloat> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -54,8 +56,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } @@ -86,12 +88,12 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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 +#if TEST_STD_VER > 11 { typedef std::pair<int, std::string> P; typedef test_allocator<std::pair<const int, std::string>> A; @@ -118,8 +120,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } @@ -151,8 +153,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } 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 index 07e77e33504f..9055e3dcd166 100644 --- 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 @@ -20,7 +20,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -46,7 +48,7 @@ int main() }, 7 ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -57,8 +59,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -80,7 +82,7 @@ int main() }, 7 ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -91,8 +93,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } 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 index 01aca134a604..db0010b3401c 100644 --- 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 @@ -20,7 +20,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -47,7 +49,7 @@ int main() 7, test_hash<std::hash<int> >(8) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -58,8 +60,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -82,7 +84,7 @@ int main() 7, test_hash<std::hash<int> >(8) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -93,8 +95,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } 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 index 08efdbd3591f..c76ce3968ad3 100644 --- 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 @@ -21,7 +21,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -49,7 +51,7 @@ int main() test_hash<std::hash<int> >(8), test_compare<std::equal_to<int> >(9) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -60,8 +62,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -85,7 +87,7 @@ int main() test_hash<std::hash<int> >(8), test_compare<std::equal_to<int> >(9) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -96,8 +98,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } 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 index e629c7f0782a..6cb57d4ff210 100644 --- 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 @@ -21,7 +21,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -50,7 +52,7 @@ int main() test_compare<std::equal_to<int> >(9), test_allocator<std::pair<const int, std::string> >(10) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -61,8 +63,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -87,7 +89,7 @@ int main() test_compare<std::equal_to<int> >(9), min_allocator<std::pair<const int, std::string> >() ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -98,8 +100,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -134,8 +136,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } 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 index 0f40e349db67..808d8946a7ec 100644 --- 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 @@ -22,7 +22,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -42,15 +44,15 @@ int main() test_allocator<std::pair<const int, std::string> >(10) ); C c = std::move(c0); - assert(c.bucket_count() == 7); + LIBCPP_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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(c.load_factor() == 0); assert(c.max_load_factor() == 1); @@ -79,7 +81,7 @@ int main() test_allocator<std::pair<const int, std::string> >(10) ); C c = std::move(c0); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -90,8 +92,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); @@ -109,15 +111,15 @@ int main() min_allocator<std::pair<const int, std::string> >() ); C c = std::move(c0); - assert(c.bucket_count() == 7); + LIBCPP_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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(c.load_factor() == 0); assert(c.max_load_factor() == 1); @@ -146,7 +148,7 @@ int main() min_allocator<std::pair<const int, std::string> >() ); C c = std::move(c0); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -157,8 +159,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); 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 index 36a1fa55a3cb..681c0e95b937 100644 --- 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 @@ -20,7 +20,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "../../../test_compare.h" #include "../../../test_hash.h" #include "test_allocator.h" @@ -63,8 +65,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); @@ -94,7 +96,7 @@ int main() A(10) ); C c(std::move(c0), A(10)); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -104,8 +106,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); @@ -136,7 +138,7 @@ int main() A() ); C c(std::move(c0), A()); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -146,8 +148,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); @@ -187,8 +189,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); 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 index 61c2969d9337..c0dc71da45d8 100644 --- 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 @@ -22,6 +22,7 @@ #include <unordered_map> #include <cassert> +#include "test_macros.h" #include "MoveOnly.h" #include "test_allocator.h" @@ -56,7 +57,7 @@ int main() { 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, ""); + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); } { typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; 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 index 16dc3dc6d4fa..c40173ede750 100644 --- 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 @@ -20,6 +20,7 @@ #include <unordered_map> #include <cassert> +#include "test_macros.h" #include "MoveOnly.h" #include "test_allocator.h" @@ -43,17 +44,17 @@ int main() { { typedef std::unordered_map<MoveOnly, MoveOnly> C; - static_assert(std::is_nothrow_move_constructible<C>::value, ""); + LIBCPP_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, ""); + LIBCPP_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, ""); + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; 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 index d2a18fa45f11..3dbcf4d15823 100644 --- 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 @@ -20,7 +20,9 @@ #include <string> #include <cassert> #include <cfloat> +#include <cstddef> +#include "test_macros.h" #include "test_iterators.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" @@ -58,8 +60,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } @@ -92,12 +94,12 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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 +#if TEST_STD_VER > 11 { typedef std::pair<int, std::string> P; typedef test_allocator<std::pair<const int, std::string>> A; @@ -125,8 +127,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } @@ -160,8 +162,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(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); } 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 index 9af18ab61f41..426b5dac18ba 100644 --- 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 @@ -21,7 +21,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "test_iterators.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" @@ -50,7 +52,7 @@ int main() C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), 10 ); - assert(c.bucket_count() == 11); + LIBCPP_ASSERT(c.bucket_count() == 11); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -61,8 +63,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -86,7 +88,7 @@ int main() C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), 10 ); - assert(c.bucket_count() == 11); + LIBCPP_ASSERT(c.bucket_count() == 11); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -97,8 +99,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } 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 index e23208dba991..ea058bdff1fc 100644 --- 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 @@ -22,7 +22,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "test_iterators.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" @@ -52,7 +54,7 @@ int main() 7, test_hash<std::hash<int> >(8) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -63,8 +65,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -89,7 +91,7 @@ int main() 7, test_hash<std::hash<int> >(8) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -100,8 +102,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } 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 index d296bab32741..1fdde2b12158 100644 --- 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 @@ -22,7 +22,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "test_iterators.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" @@ -53,7 +55,7 @@ int main() test_hash<std::hash<int> >(8), test_compare<std::equal_to<int> >(9) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -64,8 +66,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -91,7 +93,7 @@ int main() test_hash<std::hash<int> >(8), test_compare<std::equal_to<int> >(9) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -102,8 +104,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } 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 index 3b0fd9829c95..f95efbe5f53c 100644 --- 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 @@ -23,7 +23,9 @@ #include <cassert> #include <cfloat> #include <cmath> +#include <cstddef> +#include "test_macros.h" #include "test_iterators.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" @@ -55,7 +57,7 @@ int main() test_compare<std::equal_to<int> >(9), test_allocator<std::pair<const int, std::string> >(10) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -66,8 +68,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -94,7 +96,7 @@ int main() test_compare<std::equal_to<int> >(9), min_allocator<std::pair<const int, std::string> >() ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.size() == 4); assert(c.at(1) == "one"); assert(c.at(2) == "two"); @@ -105,8 +107,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } @@ -143,8 +145,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size()); + assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size()); assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(c.max_load_factor() == 1); } 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 index d2551861ec89..94833c23247d 100644 --- 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 @@ -18,6 +18,7 @@ #include <unordered_map> #include <cassert> +#include "test_macros.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" #include "../../../test_hash.h" @@ -34,7 +35,7 @@ int main() NotConstructible> > > C; C c = 7; - assert(c.bucket_count() == 7); + LIBCPP_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() == @@ -54,7 +55,7 @@ int main() NotConstructible> > > C; C c = 7; - assert(c.bucket_count() == 7); + LIBCPP_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() == 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 index 465dea21bce1..acf6b11fe9a2 100644 --- 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 @@ -18,6 +18,7 @@ #include <unordered_map> #include <cassert> +#include "test_macros.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" #include "../../../test_hash.h" @@ -34,7 +35,7 @@ int main() NotConstructible> > > C; C c(7); - assert(c.bucket_count() == 7); + LIBCPP_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() == @@ -54,7 +55,7 @@ int main() NotConstructible> > > C; C c(7); - assert(c.bucket_count() == 7); + LIBCPP_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() == 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 index f70ad7a1e5bc..42a248cc1602 100644 --- 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 @@ -18,6 +18,7 @@ #include <unordered_map> #include <cassert> +#include "test_macros.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" #include "../../../test_hash.h" @@ -36,7 +37,7 @@ int main() C c(7, test_hash<std::hash<NotConstructible> >(8) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.get_allocator() == @@ -58,7 +59,7 @@ int main() C c(7, test_hash<std::hash<NotConstructible> >(8) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >()); assert(c.get_allocator() == 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 index 184d77d69d5f..820a3652ec9e 100644 --- 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 @@ -18,6 +18,7 @@ #include <unordered_map> #include <cassert> +#include "test_macros.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" #include "../../../test_hash.h" @@ -37,7 +38,7 @@ int main() test_hash<std::hash<NotConstructible> >(8), test_compare<std::equal_to<NotConstructible> >(9) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.get_allocator() == @@ -60,7 +61,7 @@ int main() test_hash<std::hash<NotConstructible> >(8), test_compare<std::equal_to<NotConstructible> >(9) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.get_allocator() == 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 index ad4e6482c412..58c397c2b991 100644 --- 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 @@ -18,6 +18,7 @@ #include <unordered_map> #include <cassert> +#include "test_macros.h" #include "../../../NotConstructible.h" #include "../../../test_compare.h" #include "../../../test_hash.h" @@ -38,7 +39,7 @@ int main() test_compare<std::equal_to<NotConstructible> >(9), test_allocator<std::pair<const NotConstructible, NotConstructible> >(10) ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.get_allocator() == @@ -62,7 +63,7 @@ int main() test_compare<std::equal_to<NotConstructible> >(9), min_allocator<std::pair<const NotConstructible, NotConstructible> >() ); - assert(c.bucket_count() == 7); + LIBCPP_ASSERT(c.bucket_count() == 7); assert(c.hash_function() == test_hash<std::hash<NotConstructible> >(8)); assert(c.key_eq() == test_compare<std::equal_to<NotConstructible> >(9)); assert(c.get_allocator() == 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 index 5504d33f299b..8fbded4cd5fb 100644 --- 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 @@ -7,7 +7,6 @@ // //===----------------------------------------------------------------------===// -// XFAIL: libcpp-no-exceptions // <unordered_map> // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>, @@ -23,6 +22,7 @@ #include "MoveOnly.h" #include "min_allocator.h" +#include "test_macros.h" int main() { @@ -42,6 +42,7 @@ int main() assert(c.size() == 4); c.at(1) = "ONE"; assert(c.at(1) == "ONE"); +#ifndef TEST_HAS_NO_EXCEPTIONS try { c.at(11) = "eleven"; @@ -51,6 +52,7 @@ int main() { } assert(c.size() == 4); +#endif } { typedef std::unordered_map<int, std::string> C; @@ -67,6 +69,7 @@ int main() const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.size() == 4); assert(c.at(1) == "one"); +#ifndef TEST_HAS_NO_EXCEPTIONS try { c.at(11); @@ -76,6 +79,7 @@ int main() { } assert(c.size() == 4); +#endif } #if TEST_STD_VER >= 11 { @@ -95,6 +99,7 @@ int main() assert(c.size() == 4); c.at(1) = "ONE"; assert(c.at(1) == "ONE"); +#ifndef TEST_HAS_NO_EXCEPTIONS try { c.at(11) = "eleven"; @@ -104,6 +109,7 @@ int main() { } assert(c.size() == 4); +#endif } { typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, @@ -121,6 +127,7 @@ int main() const C c(a, a + sizeof(a)/sizeof(a[0])); assert(c.size() == 4); assert(c.at(1) == "one"); +#ifndef TEST_HAS_NO_EXCEPTIONS try { c.at(11); @@ -130,6 +137,7 @@ int main() { } assert(c.size() == 4); +#endif } #endif } diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp index 04d01eb466e7..471040a3374e 100644 --- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp +++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp @@ -37,22 +37,22 @@ int main() typedef std::pair<double, short> P; C c; C::const_iterator e = c.end(); - R r = c.insert(e, P(3.5, 3)); + R r = c.insert(e, P(3.5, static_cast<short>(3))); assert(c.size() == 1); assert(r->first == 3.5); assert(r->second == 3); - r = c.insert(c.end(), P(3.5, 4)); + r = c.insert(c.end(), P(3.5, static_cast<short>(4))); assert(c.size() == 1); assert(r->first == 3.5); assert(r->second == 3); - r = c.insert(c.end(), P(4.5, 4)); + r = c.insert(c.end(), P(4.5, static_cast<short>(4))); assert(c.size() == 2); assert(r->first == 4.5); assert(r->second == 4); - r = c.insert(c.end(), P(5.5, 4)); + r = c.insert(c.end(), P(5.5, static_cast<short>(4))); assert(c.size() == 3); assert(r->first == 5.5); assert(r->second == 4); @@ -90,22 +90,22 @@ int main() typedef std::pair<double, short> P; C c; C::const_iterator e = c.end(); - R r = c.insert(e, P(3.5, 3)); + R r = c.insert(e, P(3.5, static_cast<short>(3))); assert(c.size() == 1); assert(r->first == 3.5); assert(r->second == 3); - r = c.insert(c.end(), P(3.5, 4)); + r = c.insert(c.end(), P(3.5, static_cast<short>(4))); assert(c.size() == 1); assert(r->first == 3.5); assert(r->second == 3); - r = c.insert(c.end(), P(4.5, 4)); + r = c.insert(c.end(), P(4.5, static_cast<short>(4))); assert(c.size() == 2); assert(r->first == 4.5); assert(r->second == 4); - r = c.insert(c.end(), P(5.5, 4)); + r = c.insert(c.end(), P(5.5, static_cast<short>(4))); assert(c.size() == 3); assert(r->first == 5.5); assert(r->second == 4); diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp index faf5b046b5d8..8c8551e7467a 100644 --- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp +++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp @@ -32,25 +32,25 @@ int main() typedef std::pair<C::iterator, bool> R; typedef std::pair<double, short> P; C c; - R r = c.insert(P(3.5, 3)); + R r = c.insert(P(3.5, static_cast<short>(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)); + r = c.insert(P(3.5, static_cast<short>(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)); + r = c.insert(P(4.5, static_cast<short>(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)); + r = c.insert(P(5.5, static_cast<short>(4))); assert(r.second); assert(c.size() == 3); assert(r.first->first == 5.5); @@ -91,25 +91,25 @@ int main() typedef std::pair<C::iterator, bool> R; typedef std::pair<double, short> P; C c; - R r = c.insert(P(3.5, 3)); + R r = c.insert(P(3.5, static_cast<short>(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)); + r = c.insert(P(3.5, static_cast<short>(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)); + r = c.insert(P(4.5, static_cast<short>(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)); + r = c.insert(P(5.5, static_cast<short>(4))); assert(r.second); assert(c.size() == 3); assert(r.first->first == 5.5); 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 index f8f17ffec57a..fc286ceec8eb 100644 --- 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 @@ -26,6 +26,7 @@ // This tests a conforming extension #include <unordered_map> +#include <utility> #include <cassert> #include "test_macros.h" @@ -122,79 +123,65 @@ int main() typedef std::pair<const MoveOnly, MoveOnly> MapType; { typedef std::unordered_map<MoveOnly, MoveOnly> C; - C c1, c2; - static_assert(noexcept(swap(c1, c2)), ""); + static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { 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)), ""); + LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { 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)), ""); + LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { typedef std::unordered_map<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; - C c1, c2; - static_assert(!noexcept(swap(c1, c2)), ""); + static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, some_comp<MoveOnly>> C; - C c1, c2; - static_assert(!noexcept(swap(c1, c2)), ""); + static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } #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)), ""); + static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // 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)), ""); + static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // 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)), ""); + static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // 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)), ""); + static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // 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)), ""); + static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // 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)), ""); + static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // 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)), ""); + static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // 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)), ""); + static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // 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)), ""); + LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } #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 index f3d51f6da275..2044f42cfc49 100644 --- 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 @@ -18,6 +18,7 @@ #include <unordered_map> #include <string> #include <cassert> +#include <cstddef> #include "../../../test_compare.h" #include "../../../test_hash.h" @@ -32,27 +33,27 @@ int main() 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; - C c1(0, Hash(1), Compare(1), Alloc(1)); - C c2(0, Hash(2), Compare(2), Alloc(2)); + C c1(0, Hash(1), Compare(1), Alloc(1, 1)); + C c2(0, Hash(2), Compare(2), Alloc(1, 2)); c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() == 0); + LIBCPP_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.get_allocator().get_id() == 1); + assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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.get_allocator().get_id() == 2); + assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -72,12 +73,12 @@ int main() 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)); + C c1(0, Hash(1), Compare(1), Alloc(1, 1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2)); c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -89,18 +90,18 @@ int main() 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.get_allocator().get_id() == 1); + assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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.get_allocator().get_id() == 2); + assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -118,21 +119,21 @@ int main() 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)); + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1)); + C c2(0, Hash(2), Compare(2), Alloc(1, 2)); c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() == 0); + LIBCPP_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.get_allocator().get_id() == 1); + assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -140,9 +141,9 @@ int main() 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.get_allocator().get_id() == 2); + assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -171,12 +172,12 @@ int main() 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)); + C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1, 1)); + C c2(std::begin(a2), std::end(a2), 0, Hash(2), Compare(2), Alloc(1, 2)); c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -188,12 +189,12 @@ int main() 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.get_allocator().get_id() == 1); + assert(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -201,9 +202,9 @@ int main() 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.get_allocator().get_id() == 2); + assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } @@ -217,22 +218,22 @@ int main() c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -257,7 +258,7 @@ int main() c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -270,17 +271,17 @@ int main() 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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -303,16 +304,16 @@ int main() c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -321,8 +322,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -356,7 +357,7 @@ int main() c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -369,11 +370,11 @@ int main() 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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -382,8 +383,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } #if TEST_STD_VER >= 11 @@ -397,22 +398,22 @@ int main() c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -437,7 +438,7 @@ int main() c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -450,17 +451,17 @@ int main() 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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -483,16 +484,16 @@ int main() c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() == 0); + LIBCPP_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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -501,8 +502,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } { @@ -536,7 +537,7 @@ int main() c2.max_load_factor(2); swap(c1, c2); - assert(c1.bucket_count() >= 11); + assert(c1.bucket_count() >= 8); assert(c1.size() == 8); assert(c1.at(10) == "ten"); assert(c1.at(20) == "twenty"); @@ -549,11 +550,11 @@ int main() 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(static_cast<std::size_t>(std::distance(c1.begin(), c1.end())) == c1.size()); + assert(static_cast<std::size_t>(std::distance(c1.cbegin(), c1.cend())) == c1.size()); assert(c1.max_load_factor() == 2); - assert(c2.bucket_count() >= 5); + assert(c2.bucket_count() >= 4); assert(c2.size() == 4); assert(c2.at(1) == "one"); assert(c2.at(2) == "two"); @@ -562,8 +563,8 @@ int main() 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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); + assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(c2.max_load_factor() == 1); } #endif |