ci

Author: huixie90

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

@@ -16,7 +16,6 @@
 #include <cassert>
 #include <flat_map>
 #include <functional>
-#include <memory_resource>
 #include <vector>
 
 #include "test_macros.h"
@@ -68,19 +67,6 @@ int main(int, char**) {
     assert(m.keys().get_allocator().get_id() == 5);
     assert(m.values().get_allocator().get_id() == 5);
   }
-  {
-    // pmr
-    using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
-    std::pmr::monotonic_buffer_resource mr;
-    std::pmr::polymorphic_allocator<int> pa = &mr;
-    auto m1                                 = M(pa);
-    assert(m1.empty());
-    assert(m1.keys().get_allocator() == pa);
-    assert(m1.values().get_allocator() == pa);
-    auto m2 = M(&mr);
-    assert(m2.empty());
-    assert(m2.keys().get_allocator() == pa);
-    assert(m2.values().get_allocator() == pa);
-  }
+
   return 0;
 }

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

@@ -17,7 +17,6 @@
 #include <deque>
 #include <flat_map>
 #include <functional>
-#include <memory_resource>
 #include <type_traits>
 #include <vector>
 
@@ -81,17 +80,6 @@ int main(int, char**) {
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
   }
-  {
-    using M = std::flat_map<int, int, std::function<bool(int, int)>, std::pmr::vector<int>, std::pmr::vector<int>>;
-    std::pmr::monotonic_buffer_resource mr;
-    std::pmr::vector<M> vm(&mr);
-    vm.emplace_back(std::greater<int>());
-    assert(vm[0] == M{});
-    assert(vm[0].key_comp()(2, 1) == true);
-    assert(vm[0].value_comp()({2, 0}, {1, 0}) == true);
-    assert(vm[0].keys().get_allocator().resource() == &mr);
-    assert(vm[0].values().get_allocator().resource() == &mr);
-  }
   {
     // If an allocator is given, it must be usable by both containers.
     using A = test_allocator<int>;
@@ -100,5 +88,6 @@ int main(int, char**) {
     static_assert(!std::is_constructible_v<M, std::less<>, std::allocator<int>>);
     static_assert(!std::is_constructible_v<M, std::less<>, A>);
   }
+
   return 0;
 }

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

@@ -23,7 +23,6 @@
 #include <deque>
 #include <flat_map>
 #include <functional>
-#include <memory_resource>
 #include <vector>
 
 #include "min_allocator.h"
@@ -180,127 +179,6 @@ int main(int, char**) {
     assert(m2.keys().get_allocator() == A(5));
     assert(m2.values().get_allocator() == A(5));
   }
-  {
-    // pmr
-    using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
-    std::pmr::monotonic_buffer_resource mr;
-    std::pmr::vector<M> vm(&mr);
-    std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
-    std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
-    assert(ks.get_allocator().resource() != &mr);
-    assert(vs.get_allocator().resource() != &mr);
-    vm.emplace_back(ks, vs);
-    assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above
-    assert(vs.size() == 9); // vs' value is unchanged, since it was an lvalue above
-    assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
-    assert(vm[0].keys().get_allocator().resource() == &mr);
-    assert(vm[0].values().get_allocator().resource() == &mr);
-  }
-  {
-    // pmr move
-    using M = std::flat_map<int, int, std::less<int>, std::pmr::vector<int>, std::pmr::vector<int>>;
-    std::pmr::monotonic_buffer_resource mr;
-    std::pmr::vector<M> vm(&mr);
-    std::pmr::vector<int> ks = {1, 1, 1, 2, 2, 3, 2, 3, 3};
-    std::pmr::vector<int> vs = {1, 1, 1, 2, 2, 3, 2, 3, 3};
-    assert(ks.get_allocator().resource() != &mr);
-    assert(vs.get_allocator().resource() != &mr);
-    vm.emplace_back(std::move(ks), std::move(vs));
-    LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
-    LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
-    assert((vm[0] == M{{1, 1}, {2, 2}, {3, 3}}));
-    assert(vm[0].keys().get_allocator().resource() == &mr);
-    assert(vm[0].values().get_allocator().resource() == &mr);
-  }
 
-#if 0
-  // Test all combinations of lvalue and rvalue containers (LWG 3802).
-  {
-    int input[] = {1,1,1,2,2,3,2,3,3};
-    const P expected[] = {{1,1}, {2,2}, {3,3}};
-    {
-      using M = std::flat_map<int, MoveOnly, std::less<>, std::pmr::vector<int>, std::pmr::vector<MoveOnly>>;
-      std::pmr::monotonic_buffer_resource mr;
-      std::pmr::vector<M> vm(&mr);
-      std::pmr::vector<int> ks(input, input + 9);
-      std::pmr::vector<MoveOnly> vs(input, input + 9);
-      vm.emplace_back(ks, std::move(vs)); // ill-formed before LWG 3802
-      assert(ks.size() == 9);        // ks' value is unchanged, since it was an lvalue above
-      LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
-      assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
-      assert(vm[0].keys().get_allocator().resource() == &mr);
-      assert(vm[0].values().get_allocator().resource() == &mr);
-    }
-    {
-      using M = std::flat_map<MoveOnly, int, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<int>>;
-      std::pmr::monotonic_buffer_resource mr;
-      std::pmr::vector<M> vm(&mr);
-      std::pmr::vector<MoveOnly> ks(input, input + 9);
-      std::pmr::vector<int> vs(input, input + 9);
-      vm.emplace_back(std::move(ks), vs); // ill-formed before LWG 3802
-      LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
-      assert(vs.size() == 9);        // vs' value is unchanged, since it was an lvalue above
-      assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
-      assert(vm[0].keys().get_allocator().resource() == &mr);
-      assert(vm[0].values().get_allocator().resource() == &mr);
-    }
-    {
-      using M = std::flat_map<MoveOnly, MoveOnly, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
-      std::pmr::monotonic_buffer_resource mr;
-      std::pmr::vector<M> vm(&mr);
-      std::pmr::vector<MoveOnly> ks(input, input + 9);
-      std::pmr::vector<MoveOnly> vs(input, input + 9);
-      vm.emplace_back(std::move(ks), std::move(vs)); // ill-formed before LWG 3802
-      LIBCPP_ASSERT(ks.size() == 9); // ks' size is unchanged, since it uses a different allocator
-      LIBCPP_ASSERT(vs.size() == 9); // vs' size is unchanged, since it uses a different allocator
-      assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
-      assert(vm[0].keys().get_allocator().resource() == &mr);
-      assert(vm[0].values().get_allocator().resource() == &mr);
-    }
-  }
-  {
-    int input[] = {1,2,3};
-    const P expected[] = {{1,1}, {2,2}, {3,3}};
-    {
-      using M = std::flat_map<int, MoveOnly, std::less<>, std::pmr::vector<int>, std::pmr::vector<MoveOnly>>;
-      std::pmr::monotonic_buffer_resource mr;
-      std::pmr::vector<M> vm(&mr);
-      std::pmr::vector<int> ks(input, input + 3);
-      std::pmr::vector<MoveOnly> vs(input, input + 3);
-      vm.emplace_back(std::sorted_unique, ks, std::move(vs)); // ill-formed before LWG 3802
-      assert(ks.size() == 3);        // ks' value is unchanged, since it was an lvalue above
-      LIBCPP_ASSERT(vs.size() == 3); // vs' size is unchanged, since it uses a different allocator
-      assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
-      assert(vm[0].keys().get_allocator().resource() == &mr);
-      assert(vm[0].values().get_allocator().resource() == &mr);
-    }
-    {
-      using M = std::flat_map<MoveOnly, int, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<int>>;
-      std::pmr::monotonic_buffer_resource mr;
-      std::pmr::vector<M> vm(&mr);
-      std::pmr::vector<MoveOnly> ks(input, input + 3);
-      std::pmr::vector<int> vs(input, input + 3);
-      vm.emplace_back(std::sorted_unique, std::move(ks), vs); // ill-formed before LWG 3802
-      LIBCPP_ASSERT(ks.size() == 3); // ks' size is unchanged, since it uses a different allocator
-      assert(vs.size() == 3);        // vs' value is unchanged, since it was an lvalue above
-      assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
-      assert(vm[0].keys().get_allocator().resource() == &mr);
-      assert(vm[0].values().get_allocator().resource() == &mr);
-    }
-    {
-      using M = std::flat_map<MoveOnly, MoveOnly, std::less<>, std::pmr::vector<MoveOnly>, std::pmr::vector<MoveOnly>>;
-      std::pmr::monotonic_buffer_resource mr;
-      std::pmr::vector<M> vm(&mr);
-      std::pmr::vector<MoveOnly> ks(input, input + 3);
-      std::pmr::vector<MoveOnly> vs(input, input + 3);
-      vm.emplace_back(std::sorted_unique, std::move(ks), std::move(vs)); // ill-formed before LWG 3802
-      LIBCPP_ASSERT(ks.size() == 3); // ks' size is unchanged, since it uses a different allocator
-      LIBCPP_ASSERT(vs.size() == 3); // vs' size is unchanged, since it uses a different allocator
-      assert(std::ranges::equal(vm[0], expected, std::equal_to<>()));
-      assert(vm[0].keys().get_allocator().resource() == &mr);
-      assert(vm[0].values().get_allocator().resource() == &mr);
-    }
-  }
-#endif
   return 0;
 }

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

@@ -14,7 +14,6 @@
 
 #include <cassert>
 #include <flat_map>
-#include <memory_resource>
 #include <vector>
 
 #include "test_macros.h"
@@ -66,25 +65,6 @@ int main(int, char**) {
     assert(mo.keys().get_allocator() == other_allocator<int>(6));
     assert(mo.values().get_allocator() == other_allocator<char>(7));
   }
-  {
-    using C = test_less<int>;
-    std::pmr::monotonic_buffer_resource mr;
-    using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
-    auto mo = M({{1, 1}, {2, 2}, {3, 3}}, C(5), &mr);
-    auto m  = mo;
-
-    assert(m.key_comp() == C(5));
-    assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
-    auto [ks, vs] = std::move(m).extract();
-    assert(ks.get_allocator().resource() == std::pmr::get_default_resource());
-    assert(vs.get_allocator().resource() == std::pmr::get_default_resource());
 
-    // mo is unchanged
-    assert(mo.key_comp() == C(5));
-    assert((mo == M{{1, 1}, {2, 2}, {3, 3}}));
-    auto [kso, vso] = std::move(mo).extract();
-    assert(kso.get_allocator().resource() == &mr);
-    assert(vso.get_allocator().resource() == &mr);
-  }
   return 0;
 }

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

@@ -16,7 +16,6 @@
 #include <deque>
 #include <flat_map>
 #include <functional>
-#include <memory_resource>
 #include <vector>
 
 #include "test_macros.h"
@@ -63,34 +62,6 @@ int main(int, char**) {
     assert(mo.keys().get_allocator() == test_allocator<int>(6));
     assert(mo.values().get_allocator() == test_allocator<char>(7));
   }
-  {
-    // explicit(false)
-    using C = test_less<int>;
-    using M = std::flat_map<int, int, C, std::pmr::vector<int>, std::pmr::vector<int>>;
-    std::pmr::monotonic_buffer_resource mr1;
-    std::pmr::monotonic_buffer_resource mr2;
-    M mo = M({1, 2, 3}, {2, 2, 1}, C(5), &mr1);
-    M m  = {mo, &mr2}; // also test the implicitness of this constructor
 
-    assert(m.key_comp() == C(5));
-    assert((m.keys() == std::pmr::vector<int>{1, 2, 3}));
-    assert((m.values() == std::pmr::vector<int>{2, 2, 1}));
-    assert(m.keys().get_allocator().resource() == &mr2);
-    assert(m.values().get_allocator().resource() == &mr2);
-
-    // mo is unchanged
-    assert(mo.key_comp() == C(5));
-    assert((mo.keys() == std::pmr::vector<int>{1, 2, 3}));
-    assert((mo.values() == std::pmr::vector<int>{2, 2, 1}));
-    assert(mo.keys().get_allocator().resource() == &mr1);
-    assert(mo.values().get_allocator().resource() == &mr1);
-  }
-  {
-    using M = std::flat_map<int, int, std::less<>, std::pmr::vector<int>, std::pmr::deque<int>>;
-    std::pmr::vector<M> vs;
-    M m = {{1, 2}, {2, 2}, {3, 1}};
-    vs.push_back(m);
-    assert(vs[0] == m);
-  }
   return 0;
 }

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

@@ -15,7 +15,6 @@
 #include <deque>
 #include <flat_map>
 #include <functional>
-#include <memory_resource>
 #include <vector>
 
 #include "test_macros.h"
@@ -71,22 +70,6 @@ int main(int, char**) {
     assert(mo.keys().get_allocator() == other_allocator<int>(6));
     assert(mo.values().get_allocator() == other_allocator<char>(7));
   }
-  {
-    // pmr allocator is not propagated
-    using M = std::flat_map<int, int, std::less<>, std::pmr::deque<int>, std::pmr::vector<int>>;
-    std::pmr::monotonic_buffer_resource mr1;
-    std::pmr::monotonic_buffer_resource mr2;
-    M mo = M({{1, 1}, {2, 2}, {3, 3}}, &mr1);
-    M m  = M({{4, 4}, {5, 5}}, &mr2);
-    m    = mo;
-    assert((m == M{{1, 1}, {2, 2}, {3, 3}}));
-    assert(m.keys().get_allocator().resource() == &mr2);
-    assert(m.values().get_allocator().resource() == &mr2);
-
-    // mo is unchanged
-    assert((mo == M{{1, 1}, {2, 2}, {3, 3}}));
-    assert(mo.keys().get_allocator().resource() == &mr1);
-  }
   {
     // comparator is copied and invariant is preserved
     using M = std::flat_map<int, int, std::function<bool(int, int)>>;

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

@@ -18,7 +18,6 @@
 #include <list>
 #include <flat_map>
 #include <functional>
-#include <memory_resource>
 #include <ranges>
 #include <type_traits>
 #include <utility>
@@ -89,32 +88,6 @@ void test_containers() {
     assert(s.keys().get_allocator().get_id() == 44);
     assert(s.values().get_allocator().get_id() == 44);
   }
-  {
-    std::pmr::monotonic_buffer_resource mr;
-    std::pmr::monotonic_buffer_resource mr2;
-    std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
-    std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
-    std::flat_map s(std::move(pks), std::move(pvs), &mr2);
-
-    ASSERT_SAME_TYPE(
-        decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
-    assert(std::ranges::equal(s, expected));
-    assert(s.keys().get_allocator().resource() == &mr2);
-    assert(s.values().get_allocator().resource() == &mr2);
-  }
-  {
-    std::pmr::monotonic_buffer_resource mr;
-    std::pmr::monotonic_buffer_resource mr2;
-    std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
-    std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
-    std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), &mr2);
-
-    ASSERT_SAME_TYPE(
-        decltype(s), std::flat_map<int, short, std::less<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
-    assert(std::ranges::equal(s, expected));
-    assert(s.keys().get_allocator().resource() == &mr2);
-    assert(s.values().get_allocator().resource() == &mr2);
-  }
 }
 
 void test_containers_compare() {
@@ -155,32 +128,6 @@ void test_containers_compare() {
     assert(s.keys().get_allocator().get_id() == 44);
     assert(s.values().get_allocator().get_id() == 44);
   }
-  {
-    std::pmr::monotonic_buffer_resource mr;
-    std::pmr::monotonic_buffer_resource mr2;
-    std::pmr::deque<int> pks(ks.begin(), ks.end(), &mr);
-    std::pmr::deque<short> pvs(vs.begin(), vs.end(), &mr);
-    std::flat_map s(std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
-
-    ASSERT_SAME_TYPE(
-        decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
-    assert(std::ranges::equal(s, expected));
-    assert(s.keys().get_allocator().resource() == &mr2);
-    assert(s.values().get_allocator().resource() == &mr2);
-  }
-  {
-    std::pmr::monotonic_buffer_resource mr;
-    std::pmr::monotonic_buffer_resource mr2;
-    std::pmr::deque<int> pks(sorted_ks.begin(), sorted_ks.end(), &mr);
-    std::pmr::deque<short> pvs(sorted_vs.begin(), sorted_vs.end(), &mr);
-    std::flat_map s(std::sorted_unique, std::move(pks), std::move(pvs), std::greater<int>(), &mr2);
-
-    ASSERT_SAME_TYPE(
-        decltype(s), std::flat_map<int, short, std::greater<int>, std::pmr::deque<int>, std::pmr::deque<short>>);
-    assert(std::ranges::equal(s, expected));
-    assert(s.keys().get_allocator().resource() == &mr2);
-    assert(s.values().get_allocator().resource() == &mr2);
-  }
 }
 
 void test_iter_iter() {