[libcxx] r276593 - Mark bucket_count() assertions as non-portable. Patch from STL at microsoft.com

Eric Fiselier via cfe-commits cfe-commits at lists.llvm.org
Sun Jul 24 17:26:43 PDT 2016


Author: ericwf
Date: Sun Jul 24 19:26:41 2016
New Revision: 276593

URL: http://llvm.org/viewvc/llvm-project?rev=276593&view=rev
Log:
Mark bucket_count() assertions as non-portable. Patch from STL at microsoft.com

Modified:
    libcxx/trunk/test/std/containers/unord/unord.map/bucket_count.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/rehash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/reserve.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/swap_member.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/iterators.fail.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/rehash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/reserve.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/iterators.fail.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/rehash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/reserve.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/bucket_count.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/rehash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/reserve.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/swap_member.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
    libcxx/trunk/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp

Modified: libcxx/trunk/test/std/containers/unord/unord.map/bucket_count.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/bucket_count.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/bucket_count.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/bucket_count.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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;
@@ -51,7 +51,7 @@ int main()
         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>,

Modified: libcxx/trunk/test/std/containers/unord/unord.map/rehash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/rehash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/rehash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/rehash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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

Modified: libcxx/trunk/test/std/containers/unord/unord.map/reserve.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/reserve.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/reserve.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/reserve.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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);

Modified: libcxx/trunk/test/std/containers/unord/unord.map/swap_member.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/swap_member.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/swap_member.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/swap_member.pass.cpp Sun Jul 24 19:26:41 2016
@@ -37,7 +37,7 @@ 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));
@@ -46,7 +46,7 @@ int main()
         assert(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));
@@ -94,7 +94,7 @@ int main()
         assert(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));
@@ -123,7 +123,7 @@ 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));
@@ -217,7 +217,7 @@ 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));
@@ -226,7 +226,7 @@ int main()
         assert(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));
@@ -274,7 +274,7 @@ int main()
         assert(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));
@@ -303,7 +303,7 @@ 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));
@@ -397,7 +397,7 @@ 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));
@@ -406,7 +406,7 @@ int main()
         assert(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));
@@ -454,7 +454,7 @@ int main()
         assert(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));
@@ -483,7 +483,7 @@ 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));

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==
@@ -75,7 +76,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);
@@ -95,7 +96,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());

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/assign_copy.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -57,7 +58,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");
@@ -166,7 +167,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/assign_move.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -58,7 +59,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");
@@ -103,7 +104,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");
@@ -149,7 +150,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");
@@ -196,7 +197,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/copy.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -51,7 +52,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");
@@ -91,7 +92,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");
@@ -132,7 +133,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/copy_alloc.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -51,7 +52,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");
@@ -91,7 +92,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/default.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==
@@ -67,7 +68,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);

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -46,7 +47,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");
@@ -80,7 +81,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -47,7 +48,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");
@@ -82,7 +83,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -22,6 +22,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -49,7 +50,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");
@@ -85,7 +86,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/init_size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -22,6 +22,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -50,7 +51,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");
@@ -87,7 +88,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp Sun Jul 24 19:26:41 2016
@@ -23,6 +23,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -42,7 +43,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() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
@@ -79,7 +80,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");
@@ -109,7 +110,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() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
@@ -146,7 +147,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/move_alloc.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -94,7 +95,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");
@@ -136,7 +137,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -22,6 +22,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
@@ -50,7 +51,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");
@@ -86,7 +87,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -23,6 +23,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
@@ -52,7 +53,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");
@@ -89,7 +90,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -23,6 +23,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
@@ -53,7 +54,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");
@@ -91,7 +92,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -24,6 +24,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
@@ -55,7 +56,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");
@@ -94,7 +95,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");

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size.fail.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.cnstr/size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==

Modified: libcxx/trunk/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.map/unord.map.swap/swap_non_member.pass.cpp Sun Jul 24 19:26:41 2016
@@ -37,7 +37,7 @@ 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));
@@ -46,7 +46,7 @@ int main()
         assert(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));
@@ -94,7 +94,7 @@ int main()
         assert(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));
@@ -123,7 +123,7 @@ 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));
@@ -217,7 +217,7 @@ 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));
@@ -226,7 +226,7 @@ int main()
         assert(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));
@@ -274,7 +274,7 @@ int main()
         assert(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));
@@ -303,7 +303,7 @@ 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));
@@ -397,7 +397,7 @@ 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));
@@ -406,7 +406,7 @@ int main()
         assert(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));
@@ -454,7 +454,7 @@ int main()
         assert(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));
@@ -483,7 +483,7 @@ 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));

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/bucket_count.pass.cpp Sun Jul 24 19:26:41 2016
@@ -19,6 +19,8 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     {
@@ -26,7 +28,7 @@ int main()
         typedef C::const_iterator I;
         typedef std::pair<int, std::string> P;
         const C c;
-        assert(c.bucket_count() == 0);
+        LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_multimap<int, std::string> C;

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/iterators.fail.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/iterators.fail.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/iterators.fail.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/iterators.fail.cpp Sun Jul 24 19:26:41 2016
@@ -24,6 +24,8 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     {
@@ -39,7 +41,7 @@ int main()
             P(2, "four"),
         };
         C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
@@ -61,7 +63,7 @@ int main()
             P(2, "four"),
         };
         const C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/local_iterators.fail.cpp Sun Jul 24 19:26:41 2016
@@ -24,6 +24,8 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     {
@@ -40,7 +42,7 @@ int main()
             P(2, "four"),
         };
         C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         C::size_type b = c.bucket(0);
         I i = c.begin(b);
         I j = c.end(b);
@@ -105,7 +107,7 @@ int main()
             P(2, "four"),
         };
         const C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         C::size_type b = c.bucket(0);
         I i = c.begin(b);
         I j = c.end(b);
@@ -169,7 +171,7 @@ int main()
             P(2, "four"),
         };
         C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         C::size_type b = c.bucket(0);
         I i = c.cbegin(b);
         I j = c.cend(b);
@@ -233,7 +235,7 @@ int main()
             P(2, "four"),
         };
         const C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         C::size_type b = c.bucket(0);
         I i = c.cbegin(b);
         I j = c.cend(b);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/rehash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/rehash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/rehash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/rehash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
@@ -85,16 +86,16 @@ int main()
         assert(c.bucket_count() >= 7);
         c.rehash(3);
         rehash_postcondition(c, 3);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         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
@@ -116,16 +117,16 @@ int main()
         assert(c.bucket_count() >= 7);
         c.rehash(3);
         rehash_postcondition(c, 3);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         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

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/reserve.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/reserve.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/reserve.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/reserve.pass.cpp Sun Jul 24 19:26:41 2016
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
@@ -66,11 +67,11 @@ int main()
         test(c);
         assert(c.bucket_count() >= 7);
         c.reserve(3);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         test(c);
         c.max_load_factor(2);
         c.reserve(3);
-        assert(c.bucket_count() == 3);
+        LIBCPP_ASSERT(c.bucket_count() == 3);
         test(c);
         c.reserve(31);
         assert(c.bucket_count() >= 16);
@@ -94,11 +95,11 @@ int main()
         test(c);
         assert(c.bucket_count() >= 7);
         c.reserve(3);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         test(c);
         c.max_load_factor(2);
         c.reserve(3);
-        assert(c.bucket_count() == 3);
+        LIBCPP_ASSERT(c.bucket_count() == 3);
         test(c);
         c.reserve(31);
         assert(c.bucket_count() >= 16);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/swap_member.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/swap_member.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/swap_member.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/swap_member.pass.cpp Sun Jul 24 19:26:41 2016
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../test_compare.h"
 #include "../../test_hash.h"
 #include "test_allocator.h"
@@ -38,7 +39,7 @@ 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));
@@ -47,7 +48,7 @@ int main()
         assert(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));
@@ -95,7 +96,7 @@ int main()
         assert(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));
@@ -124,7 +125,7 @@ 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));
@@ -223,7 +224,7 @@ 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));
@@ -232,7 +233,7 @@ int main()
         assert(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));
@@ -280,7 +281,7 @@ int main()
         assert(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));
@@ -309,7 +310,7 @@ 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));
@@ -408,7 +409,7 @@ 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));
@@ -417,7 +418,7 @@ int main()
         assert(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));
@@ -465,7 +466,7 @@ int main()
         assert(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));
@@ -494,7 +495,7 @@ 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));

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==
@@ -75,7 +76,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);
@@ -95,7 +96,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());

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_copy.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -57,7 +58,7 @@ int main()
             A(4)
            );
         c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(i->first == 1);
@@ -194,7 +195,7 @@ int main()
             A()
            );
         c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(i->first == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/assign_move.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cassert>
 #include <cfloat>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -58,7 +59,7 @@ int main()
             A(4)
            );
         c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -123,7 +124,7 @@ int main()
             A(10)
            );
         c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -188,7 +189,7 @@ int main()
             A(4)
            );
         c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -254,7 +255,7 @@ int main()
             A()
            );
         c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -51,7 +52,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() == 6);
         C::const_iterator i = c.cbegin();
         assert(i->first == 1);
@@ -105,7 +106,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() == 6);
         C::const_iterator i = c.cbegin();
         assert(i->first == 1);
@@ -160,7 +161,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() == 6);
         C::const_iterator i = c.cbegin();
         assert(i->first == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/copy_alloc.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -51,7 +52,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() == 6);
         C::const_iterator i = c.cbegin();
         assert(i->first == 1);
@@ -105,7 +106,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() == 6);
         C::const_iterator i = c.cbegin();
         assert(i->first == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/default.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==
@@ -67,7 +68,7 @@ int main()
     }
     {
         std::unordered_multimap<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);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -46,7 +47,7 @@ int main()
             },
             7
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -102,7 +103,7 @@ int main()
             },
             7
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -47,7 +48,7 @@ int main()
             7,
             test_hash<std::hash<int> >(8)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -104,7 +105,7 @@ int main()
             7,
             test_hash<std::hash<int> >(8)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -22,6 +22,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -49,7 +50,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -107,7 +108,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/init_size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -22,6 +22,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -50,7 +51,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -109,7 +110,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -51,7 +52,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() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
@@ -88,7 +89,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -151,7 +152,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() == 0);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
@@ -188,7 +189,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move_alloc.pass.cpp Sun Jul 24 19:26:41 2016
@@ -23,6 +23,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -119,7 +120,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -184,7 +185,7 @@ int main()
             A()
            );
         C c(std::move(c0), A());
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -22,6 +22,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
@@ -50,7 +51,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -108,7 +109,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -23,6 +23,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
@@ -52,7 +53,7 @@ int main()
             7,
             test_hash<std::hash<int> >(8)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -111,7 +112,7 @@ int main()
             7,
             test_hash<std::hash<int> >(8)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -23,6 +23,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
@@ -53,7 +54,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -113,7 +114,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -24,6 +24,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
@@ -55,7 +56,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);
@@ -116,7 +117,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() == 6);
         typedef std::pair<C::const_iterator, C::const_iterator> Eq;
         Eq eq = c.equal_range(1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.fail.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -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() ==

Modified: libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multimap/unord.multimap.swap/swap_non_member.pass.cpp Sun Jul 24 19:26:41 2016
@@ -19,6 +19,7 @@
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -37,7 +38,7 @@ 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));
@@ -46,7 +47,7 @@ int main()
         assert(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));
@@ -94,7 +95,7 @@ int main()
         assert(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));
@@ -123,7 +124,7 @@ 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));
@@ -222,7 +223,7 @@ 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));
@@ -231,7 +232,7 @@ int main()
         assert(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));
@@ -279,7 +280,7 @@ int main()
         assert(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));
@@ -308,7 +309,7 @@ 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));
@@ -407,7 +408,7 @@ 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));
@@ -416,7 +417,7 @@ int main()
         assert(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));
@@ -464,7 +465,7 @@ int main()
         assert(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));
@@ -493,7 +494,7 @@ 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));

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/bucket_count.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
@@ -27,7 +28,7 @@ int main()
         typedef C::const_iterator I;
         typedef int P;
         const C c;
-        assert(c.bucket_count() == 0);
+        LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_multiset<int> C;
@@ -54,7 +55,7 @@ int main()
         typedef C::const_iterator I;
         typedef int P;
         const C c;
-        assert(c.bucket_count() == 0);
+        LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_multiset<int, std::hash<int>,

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/iterators.fail.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/iterators.fail.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/iterators.fail.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/iterators.fail.cpp Sun Jul 24 19:26:41 2016
@@ -23,6 +23,8 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     {
@@ -38,7 +40,7 @@ int main()
             P(2)
         };
         C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());
@@ -59,7 +61,7 @@ int main()
             P(2)
         };
         const C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(std::distance(c.begin(), c.end()) == c.size());
         assert(std::distance(c.cbegin(), c.cend()) == c.size());

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/local_iterators.fail.cpp Sun Jul 24 19:26:41 2016
@@ -23,6 +23,8 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main()
 {
     {
@@ -39,7 +41,7 @@ int main()
             P(2)
         };
         C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         C::size_type b = c.bucket(0);
         I i = c.begin(b);
         I j = c.end(b);
@@ -98,7 +100,7 @@ int main()
             P(2)
         };
         const C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         C::size_type b = c.bucket(0);
         I i = c.begin(b);
         I j = c.end(b);
@@ -156,7 +158,7 @@ int main()
             P(2)
         };
         C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         C::size_type b = c.bucket(0);
         I i = c.cbegin(b);
         I j = c.cend(b);
@@ -214,7 +216,7 @@ int main()
             P(2)
         };
         const C c(a, a + sizeof(a)/sizeof(a[0]));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         C::size_type b = c.bucket(0);
         I i = c.cbegin(b);
         I j = c.cend(b);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/rehash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/rehash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/rehash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/rehash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
@@ -55,16 +56,16 @@ int main()
         assert(c.bucket_count() >= 7);
         c.rehash(3);
         rehash_postcondition(c, 3);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         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
@@ -86,16 +87,16 @@ int main()
         assert(c.bucket_count() >= 7);
         c.rehash(3);
         rehash_postcondition(c, 3);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         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

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/reserve.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/reserve.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/reserve.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/reserve.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
@@ -63,11 +64,11 @@ int main()
         test(c);
         assert(c.bucket_count() >= 7);
         c.reserve(3);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         test(c);
         c.max_load_factor(2);
         c.reserve(3);
-        assert(c.bucket_count() == 3);
+        LIBCPP_ASSERT(c.bucket_count() == 3);
         test(c);
         c.reserve(31);
         assert(c.bucket_count() >= 16);
@@ -91,11 +92,11 @@ int main()
         test(c);
         assert(c.bucket_count() >= 7);
         c.reserve(3);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         test(c);
         c.max_load_factor(2);
         c.reserve(3);
-        assert(c.bucket_count() == 3);
+        LIBCPP_ASSERT(c.bucket_count() == 3);
         test(c);
         c.reserve(31);
         assert(c.bucket_count() >= 16);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/swap_member.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/swap_member.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/swap_member.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/swap_member.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../test_compare.h"
 #include "../../test_hash.h"
 #include "test_allocator.h"
@@ -36,7 +37,7 @@ 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));
@@ -45,7 +46,7 @@ int main()
         assert(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));
@@ -93,7 +94,7 @@ int main()
         assert(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));
@@ -122,7 +123,7 @@ 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));
@@ -217,7 +218,7 @@ 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));
@@ -226,7 +227,7 @@ int main()
         assert(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));
@@ -274,7 +275,7 @@ int main()
         assert(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));
@@ -303,7 +304,7 @@ 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));
@@ -398,7 +399,7 @@ 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));
@@ -407,7 +408,7 @@ int main()
         assert(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));
@@ -455,7 +456,7 @@ int main()
         assert(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));
@@ -484,7 +485,7 @@ 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));

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -33,7 +34,7 @@ int main()
                                    test_allocator<NotConstructible>
                                    > C;
         C c(test_allocator<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() == test_allocator<NotConstructible>(10));
@@ -51,7 +52,7 @@ int main()
                                    min_allocator<NotConstructible>
                                    > C;
         C c(min_allocator<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() == min_allocator<NotConstructible>());
@@ -71,7 +72,7 @@ int main()
 
         A a(43);
         C c(3, a);
-        assert(c.bucket_count() == 3);
+        LIBCPP_ASSERT(c.bucket_count() == 3);
         assert(c.hash_function() == HF());
         assert(c.key_eq() == Comp ());
         assert(c.get_allocator() == a);
@@ -92,7 +93,7 @@ int main()
         HF hf(42);
         A a(43);
         C c(4, hf, a);
-        assert(c.bucket_count() == 4);
+        LIBCPP_ASSERT(c.bucket_count() == 4);
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == HF()));
         assert(c.key_eq() == Comp ());

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_copy.pass.cpp Sun Jul 24 19:26:41 2016
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -56,7 +57,7 @@ int main()
             A(4)
            );
         c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(*i == 1);
@@ -182,7 +183,7 @@ int main()
             A()
            );
         c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(*i == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/assign_move.pass.cpp Sun Jul 24 19:26:41 2016
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -57,7 +58,7 @@ int main()
             A(4)
            );
         c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(*i == 1);
@@ -110,7 +111,7 @@ int main()
             A(10)
            );
         c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -155,7 +156,7 @@ int main()
             A(4)
            );
         c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -201,7 +202,7 @@ int main()
             A()
            );
         c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(*i == 4);
@@ -254,7 +255,7 @@ int main()
             A()
            );
         c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -50,7 +51,7 @@ int main()
             test_allocator<int>(10)
            );
         C c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(*i == 1);
@@ -97,7 +98,7 @@ int main()
             other_allocator<int>(10)
            );
         C c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(*i == 1);
@@ -145,7 +146,7 @@ int main()
             min_allocator<int>()
            );
         C c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(*i == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/copy_alloc.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -50,7 +51,7 @@ int main()
             test_allocator<int>(10)
            );
         C c(c0, test_allocator<int>(5));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(*i == 1);
@@ -97,7 +98,7 @@ int main()
             min_allocator<int>()
            );
         C c(c0, min_allocator<int>());
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         C::const_iterator i = c.cbegin();
         assert(*i == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/default.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -33,7 +34,7 @@ int main()
                                    test_allocator<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() == (test_allocator<NotConstructible>()));
@@ -51,7 +52,7 @@ int main()
                                    min_allocator<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() == (min_allocator<NotConstructible>()));
@@ -63,7 +64,7 @@ int main()
     }
     {
         std::unordered_multiset<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);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -45,7 +46,7 @@ int main()
             },
             7
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -78,7 +79,7 @@ int main()
             },
             7
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -47,7 +48,7 @@ int main()
             7,
             test_hash<std::hash<int> >(8)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -81,7 +82,7 @@ int main()
             7,
             test_hash<std::hash<int> >(8)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -48,7 +49,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() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -83,7 +84,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() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/init_size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -49,7 +50,7 @@ int main()
             test_compare<std::equal_to<int> >(9),
             test_allocator<int>(10)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -85,7 +86,7 @@ int main()
             test_compare<std::equal_to<int> >(9),
             min_allocator<int>()
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -50,7 +51,7 @@ int main()
             test_allocator<int>(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));
@@ -86,7 +87,7 @@ int main()
             test_allocator<int>(10)
            );
         C c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -126,7 +127,7 @@ int main()
             min_allocator<int>()
            );
         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));
@@ -162,7 +163,7 @@ int main()
             min_allocator<int>()
            );
         C c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move_alloc.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -101,7 +102,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() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -192,7 +193,7 @@ int main()
             A()
            );
         C c(std::move(c0), A());
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -48,7 +49,7 @@ int main()
         C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -83,7 +84,7 @@ int main()
         C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -22,6 +22,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -50,7 +51,7 @@ int main()
             7,
             test_hash<std::hash<int> >(8)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -86,7 +87,7 @@ int main()
             7,
             test_hash<std::hash<int> >(8)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -22,6 +22,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -51,7 +52,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() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -88,7 +89,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() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -23,6 +23,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -53,7 +54,7 @@ int main()
             test_compare<std::equal_to<int> >(9),
             test_allocator<int>(10)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);
@@ -91,7 +92,7 @@ int main()
             test_compare<std::equal_to<int> >(9),
             min_allocator<int>()
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 6);
         assert(c.count(1) == 2);
         assert(c.count(2) == 2);

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.fail.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -33,7 +34,7 @@ int main()
                                    test_allocator<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() == (test_allocator<NotConstructible>()));
@@ -51,7 +52,7 @@ int main()
                                    min_allocator<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() == (min_allocator<NotConstructible>()));

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -33,7 +34,7 @@ int main()
                                    test_allocator<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() == (test_allocator<NotConstructible>()));
@@ -51,7 +52,7 @@ int main()
                                    min_allocator<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() == (min_allocator<NotConstructible>()));

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -35,7 +36,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() == (test_allocator<NotConstructible>()));
@@ -55,7 +56,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() == (min_allocator<NotConstructible>()));

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -36,7 +37,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() == (test_allocator<NotConstructible>()));
@@ -57,7 +58,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() == (min_allocator<NotConstructible>()));

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -37,7 +38,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() == (test_allocator<NotConstructible>(10)));
@@ -59,7 +60,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() == (min_allocator<NotConstructible>()));

Modified: libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.multiset/unord.multiset.swap/swap_non_member.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -36,7 +37,7 @@ 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));
@@ -45,7 +46,7 @@ int main()
         assert(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));
@@ -93,7 +94,7 @@ int main()
         assert(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));
@@ -122,7 +123,7 @@ 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));
@@ -217,7 +218,7 @@ 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));
@@ -226,7 +227,7 @@ int main()
         assert(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));
@@ -274,7 +275,7 @@ int main()
         assert(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));
@@ -303,7 +304,7 @@ 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));
@@ -398,7 +399,7 @@ 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));
@@ -407,7 +408,7 @@ int main()
         assert(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));
@@ -455,7 +456,7 @@ int main()
         assert(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));
@@ -484,7 +485,7 @@ 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));

Modified: libcxx/trunk/test/std/containers/unord/unord.set/bucket_count.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/bucket_count.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/bucket_count.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/bucket_count.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 int main()
@@ -27,7 +28,7 @@ int main()
         typedef C::const_iterator I;
         typedef int P;
         const C c;
-        assert(c.bucket_count() == 0);
+        LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_set<int> C;
@@ -53,7 +54,7 @@ int main()
         typedef C::const_iterator I;
         typedef int P;
         const C c;
-        assert(c.bucket_count() == 0);
+        LIBCPP_ASSERT(c.bucket_count() == 0);
     }
     {
         typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;

Modified: libcxx/trunk/test/std/containers/unord/unord.set/rehash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/rehash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/rehash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/rehash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
@@ -55,16 +56,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
@@ -86,16 +87,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

Modified: libcxx/trunk/test/std/containers/unord/unord.set/reserve.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/reserve.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/reserve.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/reserve.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class C>
@@ -63,7 +64,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);
@@ -91,7 +92,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);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/swap_member.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/swap_member.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/swap_member.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/swap_member.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../test_compare.h"
 #include "../../test_hash.h"
 #include "test_allocator.h"
@@ -36,7 +37,7 @@ 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));
@@ -45,7 +46,7 @@ int main()
         assert(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));
@@ -93,7 +94,7 @@ int main()
         assert(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));
@@ -122,7 +123,7 @@ 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));
@@ -217,7 +218,7 @@ 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));
@@ -226,7 +227,7 @@ int main()
         assert(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));
@@ -274,7 +275,7 @@ int main()
         assert(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));
@@ -303,7 +304,7 @@ 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));
@@ -398,7 +399,7 @@ 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));
@@ -407,7 +408,7 @@ int main()
         assert(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));
@@ -455,7 +456,7 @@ int main()
         assert(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));
@@ -484,7 +485,7 @@ 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));

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -33,7 +34,7 @@ int main()
                                    test_allocator<NotConstructible>
                                    > C;
         C c(test_allocator<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() == test_allocator<NotConstructible>(10));
@@ -51,7 +52,7 @@ int main()
                                    min_allocator<NotConstructible>
                                    > C;
         C c(min_allocator<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() == min_allocator<NotConstructible>());
@@ -71,7 +72,7 @@ int main()
 
         A a(43);
         C c(3, a);
-        assert(c.bucket_count() == 3);
+        LIBCPP_ASSERT(c.bucket_count() == 3);
         assert(c.hash_function() == HF());
         assert(c.key_eq() == Comp ());
         assert(c.get_allocator() == a);
@@ -92,7 +93,7 @@ int main()
         HF hf(42);
         A a(43);
         C c(4, hf, a);
-        assert(c.bucket_count() == 4);
+        LIBCPP_ASSERT(c.bucket_count() == 4);
         assert(c.hash_function() == hf);
         assert(!(c.hash_function() == HF()));
         assert(c.key_eq() == Comp ());

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/assign_copy.pass.cpp Sun Jul 24 19:26:41 2016
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -56,7 +57,7 @@ int main()
             A(4)
            );
         c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
@@ -165,7 +166,7 @@ int main()
             A()
            );
         c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/assign_move.pass.cpp Sun Jul 24 19:26:41 2016
@@ -19,6 +19,7 @@
 #include <cassert>
 #include <cfloat>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -57,7 +58,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.count(1) == 1);
         assert(c.count(2) == 1);
@@ -102,7 +103,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.count(1) == 1);
         assert(c.count(2) == 1);
@@ -147,7 +148,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.count(1) == 1);
         assert(c.count(2) == 1);
@@ -193,7 +194,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.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/copy.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -50,7 +51,7 @@ int main()
             test_allocator<int>(10)
            );
         C c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
@@ -89,7 +90,7 @@ int main()
             other_allocator<int>(10)
            );
         C c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
@@ -129,7 +130,7 @@ int main()
             min_allocator<int>()
            );
         C c = c0;
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/copy_alloc.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -50,7 +51,7 @@ int main()
             test_allocator<int>(10)
            );
         C c(c0, test_allocator<int>(5));
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
@@ -89,7 +90,7 @@ int main()
             min_allocator<int>()
            );
         C c(c0, min_allocator<int>());
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -33,7 +34,7 @@ int main()
                                    test_allocator<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() == (test_allocator<NotConstructible>()));
@@ -51,7 +52,7 @@ int main()
                                    min_allocator<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() == (min_allocator<NotConstructible>()));
@@ -63,7 +64,7 @@ int main()
     }
     {
         std::unordered_set<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);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -45,7 +46,7 @@ int main()
             },
             7
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
@@ -78,7 +79,7 @@ int main()
             },
             7
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -47,7 +48,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.count(1) == 1);
         assert(c.count(2) == 1);
@@ -81,7 +82,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.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -48,7 +49,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.count(1) == 1);
         assert(c.count(2) == 1);
@@ -83,7 +84,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.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/init_size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -49,7 +50,7 @@ int main()
             test_compare<std::equal_to<int> >(9),
             test_allocator<int>(10)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
@@ -85,7 +86,7 @@ int main()
             test_compare<std::equal_to<int> >(9),
             min_allocator<int>()
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp Sun Jul 24 19:26:41 2016
@@ -20,6 +20,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -50,7 +51,7 @@ int main()
             test_allocator<int>(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));
@@ -86,7 +87,7 @@ int main()
             test_allocator<int>(10)
            );
         C c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
@@ -126,7 +127,7 @@ int main()
             min_allocator<int>()
            );
         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));
@@ -162,7 +163,7 @@ int main()
             min_allocator<int>()
            );
         C c = std::move(c0);
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -21,6 +21,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -48,7 +49,7 @@ int main()
         C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
@@ -83,7 +84,7 @@ int main()
         C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
             7
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -22,6 +22,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -50,7 +51,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.count(1) == 1);
         assert(c.count(2) == 1);
@@ -86,7 +87,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.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -22,6 +22,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -51,7 +52,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.count(1) == 1);
         assert(c.count(2) == 1);
@@ -88,7 +89,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.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -23,6 +23,7 @@
 #include <cfloat>
 #include <cmath>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -53,7 +54,7 @@ int main()
             test_compare<std::equal_to<int> >(9),
             test_allocator<int>(10)
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);
@@ -91,7 +92,7 @@ int main()
             test_compare<std::equal_to<int> >(9),
             min_allocator<int>()
            );
-        assert(c.bucket_count() == 7);
+        LIBCPP_ASSERT(c.bucket_count() == 7);
         assert(c.size() == 4);
         assert(c.count(1) == 1);
         assert(c.count(2) == 1);

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size.fail.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -32,7 +33,7 @@ int main()
                                    test_allocator<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() == (test_allocator<NotConstructible>()));

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -33,7 +34,7 @@ int main()
                                    test_allocator<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() == (test_allocator<NotConstructible>()));
@@ -51,7 +52,7 @@ int main()
                                    min_allocator<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() == (min_allocator<NotConstructible>()));

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -35,7 +36,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() == (test_allocator<NotConstructible>()));
@@ -55,7 +56,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() == (min_allocator<NotConstructible>()));

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -36,7 +37,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() == (test_allocator<NotConstructible>()));
@@ -57,7 +58,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() == (min_allocator<NotConstructible>()));

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.cnstr/size_hash_equal_allocator.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../NotConstructible.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
@@ -37,7 +38,7 @@ int main()
             test_compare<std::equal_to<NotConstructible> >(9),
             test_allocator<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() == (test_allocator<NotConstructible>(10)));
@@ -59,7 +60,7 @@ int main()
             test_compare<std::equal_to<NotConstructible> >(9),
             min_allocator<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() == (min_allocator<NotConstructible>()));

Modified: libcxx/trunk/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp?rev=276593&r1=276592&r2=276593&view=diff
==============================================================================
--- libcxx/trunk/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp (original)
+++ libcxx/trunk/test/std/containers/unord/unord.set/unord.set.swap/swap_non_member.pass.cpp Sun Jul 24 19:26:41 2016
@@ -18,6 +18,7 @@
 #include <unordered_set>
 #include <cassert>
 
+#include "test_macros.h"
 #include "../../../test_compare.h"
 #include "../../../test_hash.h"
 #include "test_allocator.h"
@@ -36,7 +37,7 @@ 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));
@@ -45,7 +46,7 @@ int main()
         assert(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));
@@ -93,7 +94,7 @@ int main()
         assert(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));
@@ -122,7 +123,7 @@ 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));
@@ -217,7 +218,7 @@ 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));
@@ -226,7 +227,7 @@ int main()
         assert(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));
@@ -274,7 +275,7 @@ int main()
         assert(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));
@@ -303,7 +304,7 @@ 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));
@@ -398,7 +399,7 @@ 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));
@@ -407,7 +408,7 @@ int main()
         assert(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));
@@ -455,7 +456,7 @@ int main()
         assert(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));
@@ -484,7 +485,7 @@ 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));




More information about the cfe-commits mailing list