more tests

Author: huixie90

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

@@ -22,6 +22,7 @@
 #include <functional>
 #include <type_traits>
 #include <vector>
+#include <ranges>
 
 #include "test_macros.h"
 #include "min_allocator.h"
@@ -77,26 +78,26 @@ void test() {
     static_assert(!std::is_constructible_v<M, std::initializer_list<const int>, std::allocator<int>>);
   }
 
-  int expected[] = {1, 2, 3, 5};
+  int expected[] = {1, 2, 2, 3, 3, 5};
   {
     // flat_multiset(initializer_list<value_type>);
     using M                       = std::flat_multiset<int>;
     std::initializer_list<int> il = {5, 2, 2, 3, 1, 3};
     M m(il);
-    assert(std::equal(m.begin(), m.end(), expected, expected + 4));
+    assert(std::ranges::equal(m, expected));
   }
   {
     // flat_multiset(initializer_list<value_type>);
     // explicit(false)
     using M = std::flat_multiset<int>;
     M m     = {5, 2, 2, 3, 1, 3};
-    assert(std::equal(m.begin(), m.end(), expected, expected + 4));
+    assert(std::ranges::equal(m, expected));
   }
   {
     // flat_multiset(initializer_list<value_type>);
     using M = std::flat_multiset<int, std::greater<int>, std::deque<int, min_allocator<int>>>;
     M m     = {5, 2, 2, 3, 1, 3};
-    assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
+    assert(std::ranges::equal(m, expected | std::views::reverse));
   }
   {
     using A = explicit_allocator<int>;
@@ -105,7 +106,7 @@ void test() {
       // different comparator
       using M = std::flat_multiset<int, DefaultCtableComp, std::vector<int, A>>;
       M m     = {1, 2, 3};
-      assert(m.size() == 1);
+      assert(m.size() == 3);
       LIBCPP_ASSERT(*m.begin() == 1);
       assert(m.key_comp().default_constructed_);
     }
@@ -114,15 +115,15 @@ void test() {
       using M = std::flat_multiset<int, std::greater<int>, std::deque<int, A>>;
       A a;
       M m({5, 2, 2, 3, 1, 3}, a);
-      assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
+      assert(std::ranges::equal(m, expected | std::views::reverse));
     }
   }
   {
     // flat_multiset(initializer_list<value_type>, const key_compare&);
     using C = test_less<int>;
     using M = std::flat_multiset<int, C>;
     auto m  = M({5, 2, 2, 3, 1, 3}, C(10));
-    assert(std::equal(m.begin(), m.end(), expected, expected + 4));
+    assert(std::ranges::equal(m, expected));
     assert(m.key_comp() == C(10));
 
     // explicit(false)
@@ -134,8 +135,8 @@ void test() {
     // flat_multiset(initializer_list<value_type>, const key_compare&);
     // Sorting uses the comparator that was passed in
     using M = std::flat_multiset<int, std::function<bool(int, int)>, std::deque<int, min_allocator<int>>>;
-    auto m  = M({5, 2, 2, 1, 3, 1}, std::greater<int>());
-    assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
+    auto m  = M({5, 2, 2, 1, 3, 3}, std::greater<int>());
+    assert(std::ranges::equal(m, expected | std::views::reverse));
     assert(m.key_comp()(2, 1) == true);
   }
   {
@@ -144,7 +145,7 @@ void test() {
     using M = std::flat_multiset<int, std::greater<int>, std::deque<int, A>>;
     A a;
     M m({5, 2, 2, 3, 1, 3}, {}, a);
-    assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
+    assert(std::ranges::equal(m, expected | std::views::reverse));
   }
 }
 

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

@@ -21,6 +21,7 @@
 #include <deque>
 #include <flat_set>
 #include <functional>
+#include <ranges>
 #include <vector>
 
 #include "min_allocator.h"
@@ -55,7 +56,7 @@ void test() {
   }
 
   int ar[]       = {1, 1, 1, 2, 2, 3, 2, 3, 3};
-  int expected[] = {1, 2, 3};
+  int expected[] = {1, 1,1,2,2,2,3,3,3};
   {
     // flat_multiset(InputIterator , InputIterator)
     // cpp17_input_iterator
@@ -72,7 +73,7 @@ void test() {
     // greater
     using M = std::flat_multiset<int, std::greater<int>, std::deque<int, min_allocator<int>>>;
     auto m  = M(cpp17_input_iterator<const int*>(ar), cpp17_input_iterator<const int*>(ar + 9));
-    assert(std::ranges::equal(m, std::deque<int, min_allocator<int>>{3, 2, 1}));
+    assert(std::ranges::equal(m, expected | std::views::reverse));
   }
   {
     // flat_multiset(InputIterator , InputIterator)

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

@@ -42,15 +42,15 @@ void test() {
     static_assert(!std::is_constructible_v<M2, M2&&, const A1&>);
   }
   {
-    int expected[] = {1, 2, 3};
+    int expected[] = {1, 1, 2, 2, 3};
     using C        = test_less<int>;
     using A        = test_allocator<int>;
     using M        = std::flat_multiset<int, C, std::deque<int, A>>;
-    auto mo        = M(expected, expected + 3, C(5), A(7));
+    auto mo        = M(expected, expected + 5, C(5), A(7));
     auto m         = M(std::move(mo), A(3));
 
     assert(m.key_comp() == C(5));
-    assert(m.size() == 3);
+    assert(m.size() == 5);
     auto keys = std::move(m).extract();
     assert(keys.get_allocator() == A(3));
     assert(std::ranges::equal(keys, expected));
@@ -64,10 +64,10 @@ void test() {
   {
     // moved-from object maintains invariant if one of underlying container does not clear after move
     using M = std::flat_multiset<int, std::less<>, CopyOnlyVector<int>>;
-    M m1    = M({1, 2, 3});
+    M m1    = M({1, 2, 2, 1, 3});
     M m2(std::move(m1), std::allocator<int>{});
-    assert(m2.size() == 3);
-    check_invariant(m1);
+    assert(m2.size() == 5);
+    assert(std::ranges::is_sorted(m1));
     LIBCPP_ASSERT(m1.empty());
   }
 }