review

Author: huixie90

libcxx/include/__flat_set/flat_set.h

@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 
 template <class KeyContainer>
-void test() {
+void test_one() {
   using Key = typename KeyContainer::value_type;
   using M   = std::flat_set<Key, std::less<int>, KeyContainer>;
   M m;
@@ -38,11 +38,15 @@ void test() {
   assert(m.empty());
 }
 
+void test() {
+  test_one<std::vector<int>>();
+  test_one<std::deque<int>>();
+  test_one<MinSequenceContainer<int>>();
+  test_one<std::vector<int, min_allocator<int>>>();
+}
+
 int main(int, char**) {
-  test<std::vector<int>>();
-  test<std::deque<int>>();
-  test<MinSequenceContainer<int>>();
-  test<std::vector<int, min_allocator<int>>>();
+  test();
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.pass.cpp

@@ -24,7 +24,8 @@
 #include "test_allocator.h"
 #include "test_macros.h"
 
-int main(int, char**) {
+void test() {
+
   {
     using A1 = limited_allocator<int, 10>;
     using C  = std::flat_set<int, std::less<int>, std::vector<int, A1>>;
@@ -59,5 +60,10 @@ int main(int, char**) {
     assert(c.max_size() <= max_dist);
     assert(c.max_size() <= alloc_max_size(std::allocator<char>()));
   }
+}
+
+int main(int, char**) {
+  test();
+
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/max_size.pass.cpp

@@ -23,7 +23,7 @@
 #include "min_allocator.h"
 
 template <class KeyContainer>
-void test() {
+void test_one() {
   using M = std::flat_set<int, std::less<int>, KeyContainer>;
   using S = typename M::size_type;
   {
@@ -56,11 +56,15 @@ void test() {
   }
 }
 
+void test() {
+  test_one<std::vector<int>>();
+  test_one<std::deque<int>>();
+  test_one<MinSequenceContainer<int>>();
+  test_one<std::vector<int, min_allocator<int>>>();
+}
+
 int main(int, char**) {
-  test<std::vector<int>>();
-  test<std::deque<int>>();
-  test<MinSequenceContainer<int>>();
-  test<std::vector<int, min_allocator<int>>>();
+  test();
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/size.pass.cpp

@@ -22,7 +22,7 @@
 #include "test_allocator.h"
 #include "../../../test_compare.h"
 
-int main(int, char**) {
+void test() {
   {
     // The constructors in this subclause shall not participate in overload
     // resolution unless uses_allocator_v<container_type, Alloc> is true.
@@ -55,6 +55,10 @@ int main(int, char**) {
     auto v = std::move(m).extract();
     assert(v.get_allocator().get_id() == 5);
   }
+}
+
+int main(int, char**) {
+  test();
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/alloc.pass.cpp

@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 
 template <class KeyContainer>
-void test() {
+void test_one() {
   using Key = typename KeyContainer::value_type;
   using M   = std::flat_set<Key, std::less<Key>, KeyContainer>;
   {
@@ -33,7 +33,6 @@ void test() {
     m              = {3, 1, 2, 2, 3, 4, 3, 5, 6, 5};
     int expected[] = {1, 2, 3, 4, 5, 6};
     assert(std::ranges::equal(m, expected));
-    LIBCPP_ASSERT(std::ranges::equal(m, expected));
   }
   {
     M m = {10, 8};
@@ -44,13 +43,17 @@ void test() {
   }
 }
 
+void test() {
+  test_one<std::vector<int>>();
+  test_one<std::vector<int>>();
+  test_one<std::deque<int>>();
+  test_one<MinSequenceContainer<int>>();
+  test_one<std::vector<int, min_allocator<int>>>();
+  test_one<std::vector<int, min_allocator<int>>>();
+}
+
 int main(int, char**) {
-  test<std::vector<int>>();
-  test<std::vector<int>>();
-  test<std::deque<int>>();
-  test<MinSequenceContainer<int>>();
-  test<std::vector<int, min_allocator<int>>>();
-  test<std::vector<int, min_allocator<int>>>();
+  test();
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/assign_initializer_list.pass.cpp

@@ -24,7 +24,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main(int, char**) {
+void test() {
   {
     // The constructors in this subclause shall not participate in overload
     // resolution unless uses_allocator_v<container_type, Alloc> is true.
@@ -78,6 +78,10 @@ int main(int, char**) {
     auto keys = std::move(m).extract();
     assert(keys.get_allocator() == A1(5));
   }
+}
+
+int main(int, char**) {
+  test();
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/compare.pass.cpp

@@ -36,7 +36,7 @@ void conversion_test(T);
 template <class T, class... Args>
 concept ImplicitlyConstructible = requires(Args&&... args) { conversion_test<T>({std::forward<Args>(args)...}); };
 
-int main(int, char**) {
+void test() {
   {
     // The constructors in this subclause shall not participate in overload
     // resolution unless uses_allocator_v<container_type, Alloc> is true.
@@ -116,21 +116,16 @@ int main(int, char**) {
     auto m  = M(ks, A(4)); // replaces the allocators
     assert(!ks.empty());   // it was an lvalue above
     assert((m == M{1, 2, 3}));
-    auto keys = std::move(m).extract();
+    auto keys = M(m).extract();
     assert(keys.get_allocator() == A(4));
-  }
-  {
-    // flat_set(container_type , const Allocator&)
+
     // explicit(false)
-    using A = test_allocator<int>;
-    using M = std::flat_set<int, std::less<int>, std::deque<int, A>>;
     static_assert(ImplicitlyConstructible<M, const std::deque<int, A>&, const A&>);
-    auto ks = std::deque<int, A>({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5));
-    M m     = {ks, A(4)}; // implicit ctor
-    assert(!ks.empty());  // it was an lvalue above
-    assert((m == M{1, 2, 3}));
-    auto keys = std::move(m).extract();
-    assert(keys.get_allocator() == A(4));
+    M m2 = {ks, A(4)};   // implicit ctor
+    assert(!ks.empty()); // it was an lvalue above
+    assert(m2 == m);
+    auto keys2 = std::move(m).extract();
+    assert(keys2.get_allocator() == A(4));
   }
   {
     // flat_set(container_type , key_compare, const Allocator&)
@@ -153,6 +148,10 @@ int main(int, char**) {
     keys = std::move(m2).extract();
     assert(keys.get_allocator() == A(5));
   }
+}
+
+int main(int, char**) {
+  test();
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/containers.pass.cpp

@@ -21,7 +21,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main(int, char**) {
+void test() {
   {
     using C = test_less<int>;
     std::vector<int, test_allocator<int>> ks({1, 3, 5}, test_allocator<int>(6));
@@ -59,6 +59,10 @@ int main(int, char**) {
     auto keys2 = std::move(mo).extract();
     assert(keys2.get_allocator() == other_allocator<int>(6));
   }
+}
+
+int main(int, char**) {
+  test();
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy.pass.cpp

@@ -23,7 +23,7 @@
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main(int, char**) {
+void test() {
   {
     // The constructors in this subclause shall not participate in overload
     // resolution unless uses_allocator_v<container_type, Alloc> is true.
@@ -58,6 +58,10 @@ int main(int, char**) {
     auto keys2 = std::move(mo).extract();
     assert(keys2.get_allocator() == test_allocator<int>(6));
   }
+}
+
+int main(int, char**) {
+  test();
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_alloc.pass.cpp

@@ -17,11 +17,12 @@
 #include <functional>
 #include <vector>
 
+#include "operator_hijacker.h"
 #include "test_macros.h"
 #include "../../../test_compare.h"
 #include "test_allocator.h"
 
-int main(int, char**) {
+void test() {
   {
     // test_allocator is not propagated
     using C = test_less<int>;
@@ -81,5 +82,19 @@ int main(int, char**) {
     m       = static_cast<const M&>(m);
     assert((m == M{{1, 2}}));
   }
+  {
+    // Validate whether the container can be copy-assigned (move-assigned, swapped)
+    // with an ADL-hijacking operator&
+    std::flat_set<operator_hijacker> so;
+    std::flat_set<operator_hijacker> s;
+    s = so;
+    s = std::move(so);
+    swap(s, so);
+  }
+}
+
+int main(int, char**) {
+  test();
+
   return 0;
 }