diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
index 4f9797d5bf810..227f881218248 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp
@@ -26,10 +26,10 @@ int main(int, char**) {
     // test_allocator is not propagated
     using C = test_less<int>;
     std::vector<int, test_allocator<int>> ks({1, 3, 5}, test_allocator<int>(6));
-    std::vector<char, test_allocator<char>> vs({2, 2, 1}, test_allocator<char>(7));
+    std::vector<char, test_allocator<char>> vs({'2', '2', '1'}, test_allocator<char>(7));
     using M = std::flat_map<int, char, C, decltype(ks), decltype(vs)>;
     auto mo = M(ks, vs, C(5));
-    auto m  = M({{3, 3}, {4, 4}, {5, 5}}, C(3), test_allocator<int>(2));
+    auto m  = M({{3, '3'}, {4, '4'}, {5, '5'}}, C(3), test_allocator<int>(2));
     m       = mo;
 
     assert(m.key_comp() == C(5));
@@ -51,10 +51,10 @@ int main(int, char**) {
     using Ks = std::vector<int, other_allocator<int>>;
     using Vs = std::vector<char, other_allocator<char>>;
     auto ks  = Ks({1, 3, 5}, other_allocator<int>(6));
-    auto vs  = Vs({2, 2, 1}, other_allocator<char>(7));
+    auto vs  = Vs({'2', '2', '1'}, other_allocator<char>(7));
     using M  = std::flat_map<int, char, C, Ks, Vs>;
     auto mo  = M(Ks(ks, other_allocator<int>(6)), Vs(vs, other_allocator<int>(7)), C(5));
-    auto m   = M({{3, 3}, {4, 4}, {5, 5}}, C(3), other_allocator<int>(2));
+    auto m   = M({{3, '3'}, {4, '4'}, {5, '5'}}, C(3), other_allocator<int>(2));
     m        = mo;
 
     assert(m.key_comp() == C(5));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
index 009392feb3862..84c5cba2b572c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp
@@ -31,19 +31,19 @@ using PC = std::pair<const int, long>;
 
 void test_copy() {
   {
-    std::flat_map<long, short> source = {{1, 2}, {2, 3}};
+    std::flat_map<long, short> source = {{1, short{2}}, {2, short{3}}};
     std::flat_map s(source);
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s == source);
   }
   {
-    std::flat_map<long, short, std::greater<long>> source = {{1, 2}, {2, 3}};
+    std::flat_map<long, short, std::greater<long>> source = {{1, short{2}}, {2, short{3}}};
     std::flat_map s{source}; // braces instead of parens
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s == source);
   }
   {
-    std::flat_map<long, short, std::greater<long>> source = {{1, 2}, {2, 3}};
+    std::flat_map<long, short, std::greater<long>> source = {{1, short{2}}, {2, short{3}}};
     std::flat_map s(source, std::allocator<int>());
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s == source);
@@ -55,7 +55,7 @@ void test_containers() {
   std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
   std::deque<int, test_allocator<int>> sorted_ks({1, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
   std::deque<short, test_allocator<short>> sorted_vs({1, 2, 5, 4}, test_allocator<int>(0, 43));
-  const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
+  const std::pair<int, short> expected[] = {{1, short{1}}, {2, short{2}}, {3, short{5}}, {INT_MAX, short{4}}};
   {
     std::flat_map s(ks, vs);
 
@@ -95,7 +95,7 @@ void test_containers_compare() {
   std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
   std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator<int>(0, 42));
   std::deque<short, test_allocator<short>> sorted_vs({4, 5, 2, 1}, test_allocator<int>(0, 43));
-  const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
+  const std::pair<int, short> expected[] = {{INT_MAX, short{4}}, {3, short{5}}, {2, short{2}}, {1, short{1}}};
   {
     std::flat_map s(ks, vs, std::greater<int>());
 
@@ -278,8 +278,9 @@ void test_initializer_list_compare() {
 }
 
 void test_from_range() {
-  std::list<std::pair<int, short>> r     = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
-  const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
+  std::list<std::pair<int, short>> r = {
+      {1, short{1}}, {2, short{2}}, {1, short{1}}, {INT_MAX, short{4}}, {3, short{5}}};
+  const std::pair<int, short> expected[] = {{1, short{1}}, {2, short{2}}, {3, short{5}}, {INT_MAX, short{4}}};
   {
     std::flat_map s(std::from_range, r);
     ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>>);
@@ -301,8 +302,9 @@ void test_from_range() {
 }
 
 void test_from_range_compare() {
-  std::list<std::pair<int, short>> r     = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
-  const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
+  std::list<std::pair<int, short>> r = {
+      {1, short{1}}, {2, short{2}}, {1, short{1}}, {INT_MAX, short{4}}, {3, short{5}}};
+  const std::pair<int, short> expected[] = {{INT_MAX, short{4}}, {3, short{5}}, {2, short{2}}, {1, short{1}}};
   {
     std::flat_map s(std::from_range, r, std::greater<int>());
     ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>>);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp
index 11c18ac13c76a..1da2c30fff503 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp
@@ -35,7 +35,7 @@ void test_containers() {
   std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
   std::deque<int, test_allocator<int>> sorted_ks({1, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
   std::deque<short, test_allocator<short>> sorted_vs({1, 2, 5, 4}, test_allocator<int>(0, 43));
-  const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
+  const std::pair<int, short> expected[] = {{1, short{1}}, {2, short{2}}, {3, short{5}}, {INT_MAX, short{4}}};
   {
     std::pmr::monotonic_buffer_resource mr;
     std::pmr::monotonic_buffer_resource mr2;
@@ -69,7 +69,7 @@ void test_containers_compare() {
   std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));
   std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator<int>(0, 42));
   std::deque<short, test_allocator<short>> sorted_vs({4, 5, 2, 1}, test_allocator<int>(0, 43));
-  const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};
+  const std::pair<int, short> expected[] = {{INT_MAX, short{4}}, {3, short{5}}, {2, short{2}}, {1, short{1}}};
   {
     std::pmr::monotonic_buffer_resource mr;
     std::pmr::monotonic_buffer_resource mr2;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
index 7a22746845d00..bedd403a067b8 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp
@@ -82,11 +82,12 @@ int main(int, char**) {
         !std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, std::allocator<int>>);
   }
 
-  std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 3}, {5, 2}};
+  std::pair<int, short> expected[] = {{1, short{1}}, {2, short{2}}, {3, short{3}}, {5, short{2}}};
   {
     // flat_map(initializer_list<value_type>);
     using M                                         = std::flat_map<int, short>;
-    std::initializer_list<std::pair<int, short>> il = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+    std::initializer_list<std::pair<int, short>> il = {
+        {5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}};
     M m(il);
     assert(std::equal(m.begin(), m.end(), expected, expected + 4));
   }
@@ -94,13 +95,13 @@ int main(int, char**) {
     // flat_map(initializer_list<value_type>);
     // explicit(false)
     using M = std::flat_map<int, short>;
-    M m     = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+    M m     = {{5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}};
     assert(std::equal(m.begin(), m.end(), expected, expected + 4));
   }
   {
     // flat_map(initializer_list<value_type>);
     using M = std::flat_map<int, short, std::greater<int>, std::deque<int, min_allocator<int>>>;
-    M m     = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+    M m     = {{5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}};
     assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
   }
   {
@@ -127,12 +128,12 @@ int main(int, char**) {
     // flat_map(initializer_list<value_type>, const key_compare&);
     using C = test_less<int>;
     using M = std::flat_map<int, short, C>;
-    auto m  = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, C(10));
+    auto m  = M({{5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}}, C(10));
     assert(std::equal(m.begin(), m.end(), expected, expected + 4));
     assert(m.key_comp() == C(10));
 
     // explicit(false)
-    M m2 = {{{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, C(10)};
+    M m2 = {{{5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}}, C(10)};
     assert(m2 == m);
     assert(m2.key_comp() == C(10));
   }
@@ -140,7 +141,8 @@ int main(int, char**) {
     // flat_map(initializer_list<value_type>, const key_compare&);
     // Sorting uses the comparator that was passed in
     using M = std::flat_map<int, short, std::function<bool(int, int)>, std::deque<int, min_allocator<int>>>;
-    auto m  = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, std::greater<int>());
+    auto m  = M({{5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}},
+               std::greater<int>());
     assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4));
     assert(m.key_comp()(2, 1) == true);
   }
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
index 7c0c487969943..d940cfb0ebde9 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp
@@ -57,9 +57,18 @@ int main(int, char**) {
     static_assert(!std::is_constructible_v<M3, Iter3, Iter3, const C&, const A2&>);
   }
 
-  using P      = std::pair<int, short>;
-  P ar[]       = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
-  P expected[] = {{1, 1}, {2, 4}, {3, 6}};
+  using P = std::pair<int, short>;
+  P ar[]  = {
+      {1, short{1}},
+      {1, short{2}},
+      {1, short{3}},
+      {2, short{4}},
+      {2, short{5}},
+      {3, short{6}},
+      {2, short{7}},
+      {3, short{8}},
+      {3, short{9}}};
+  P expected[] = {{1, short{1}}, {2, short{4}}, {3, short{6}}};
   {
     // flat_map(InputIterator , InputIterator)
     // cpp17_input_iterator
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
index a94c442c695dd..924ce9e520b6c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp
@@ -32,10 +32,10 @@ int main(int, char**) {
     using A1 = test_allocator<int>;
     using A2 = test_allocator<char>;
     using M  = std::flat_map<int, char, C, std::vector<int, A1>, std::vector<char, A2>>;
-    M mo     = M({{1, 1}, {2, 3}, {3, 2}}, C(5), A1(7));
+    M mo     = M({{1, '1'}, {2, '3'}, {3, '2'}}, C(5), A1(7));
     M m      = M({}, C(3), A1(7));
     m        = std::move(mo);
-    assert((m == M{{1, 1}, {2, 3}, {3, 2}}));
+    assert((m == M{{1, '1'}, {2, '3'}, {3, '2'}}));
     assert(m.key_comp() == C(5));
     auto [ks, vs] = std::move(m).extract();
     assert(ks.get_allocator() == A1(7));
@@ -47,10 +47,10 @@ int main(int, char**) {
     using A1 = other_allocator<int>;
     using A2 = other_allocator<char>;
     using M  = std::flat_map<int, char, C, std::deque<int, A1>, std::deque<char, A2>>;
-    M mo     = M({{4, 5}, {5, 4}}, C(5), A1(7));
-    M m      = M({{1, 1}, {2, 2}, {3, 3}, {4, 4}}, C(3), A1(7));
+    M mo     = M({{4, '5'}, {5, '4'}}, C(5), A1(7));
+    M m      = M({{1, '1'}, {2, '2'}, {3, '3'}, {4, '4'}}, C(3), A1(7));
     m        = std::move(mo);
-    assert((m == M{{4, 5}, {5, 4}}));
+    assert((m == M{{4, '5'}, {5, '4'}}));
     assert(m.key_comp() == C(5));
     auto [ks, vs] = std::move(m).extract();
     assert(ks.get_allocator() == A1(7));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp
index 154af11bb9b4d..cf3d432ae22cc 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp
@@ -166,9 +166,18 @@ int main(int, char**) {
   }
   {
     // flat_map(InputIterator first, InputIterator last, const Allocator& a);
-    using P      = std::pair<int, short>;
-    P ar[]       = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
-    P expected[] = {{1, 1}, {2, 4}, {3, 6}};
+    using P = std::pair<int, short>;
+    P ar[]  = {
+        {1, short{1}},
+        {1, short{2}},
+        {1, short{3}},
+        {2, short{4}},
+        {2, short{5}},
+        {3, short{6}},
+        {2, short{7}},
+        {3, short{8}},
+        {3, short{9}}};
+    P expected[] = {{1, short{1}}, {2, short{4}}, {3, short{6}}};
     {
       //  cpp17 iterator
       using M = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
@@ -242,9 +251,18 @@ int main(int, char**) {
   }
   {
     //  flat_map(from_range_t, R&&, const Alloc&);
-    using P      = std::pair<int, short>;
-    P ar[]       = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
-    P expected[] = {{1, 1}, {2, 4}, {3, 6}};
+    using P = std::pair<int, short>;
+    P ar[]  = {
+        {1, short{1}},
+        {1, short{2}},
+        {1, short{3}},
+        {2, short{4}},
+        {2, short{5}},
+        {3, short{6}},
+        {2, short{7}},
+        {3, short{8}},
+        {3, short{9}}};
+    P expected[] = {{1, short{1}}, {2, short{4}}, {3, short{6}}};
     {
       // input_range
       using M    = std::flat_map<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
index 282cc71f31994..d3a5c83bebb86 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp
@@ -117,9 +117,18 @@ int main(int, char**) {
     static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const C&, const A1&>);
   }
 
-  using P      = std::pair<int, short>;
-  P ar[]       = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
-  P expected[] = {{1, 1}, {2, 4}, {3, 6}};
+  using P = std::pair<int, short>;
+  P ar[]  = {
+      {1, short{1}},
+      {1, short{2}},
+      {1, short{3}},
+      {2, short{4}},
+      {2, short{5}},
+      {3, short{6}},
+      {2, short{7}},
+      {3, short{8}},
+      {3, short{9}}};
+  P expected[] = {{1, short{1}}, {2, short{4}}, {3, short{6}}};
   {
     // flat_map(from_range_t, R&&)
     // input_range && !common
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
index 3c8868f2ff424..cb5b744984ab3 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp
@@ -61,16 +61,16 @@ int main(int, char**) {
     // flat_map(sorted_unique_t, key_container_type , mapped_container_type)
     using M              = std::flat_map<int, char>;
     std::vector<int> ks  = {1, 2, 4, 10};
-    std::vector<char> vs = {4, 3, 2, 1};
+    std::vector<char> vs = {'4', '3', '2', '1'};
     auto ks2             = ks;
     auto vs2             = vs;
 
     auto m = M(std::sorted_unique, ks, vs);
-    assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
+    assert((m == M{{1, '4'}, {2, '3'}, {4, '2'}, {10, '1'}}));
     m = M(std::sorted_unique, std::move(ks), std::move(vs));
     assert(ks.empty()); // it was moved-from
     assert(vs.empty()); // it was moved-from
-    assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
+    assert((m == M{{1, '4'}, {2, '3'}, {4, '2'}, {10, '1'}}));
 
     // explicit(false)
     M m2 = {std::sorted_unique, std::move(ks2), std::move(vs2)};
@@ -83,13 +83,13 @@ int main(int, char**) {
     using Vs = std::deque<char, min_allocator<char>>;
     using M  = std::flat_map<int, char, std::greater<int>, Ks, Vs>;
     Ks ks    = {10, 4, 2, 1};
-    Vs vs    = {1, 2, 3, 4};
+    Vs vs    = {'1', '2', '3', '4'};
     auto m   = M(std::sorted_unique, ks, vs);
-    assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
+    assert((m == M{{1, '4'}, {2, '3'}, {4, '2'}, {10, '1'}}));
     m = M(std::sorted_unique, std::move(ks), std::move(vs));
     assert(ks.empty()); // it was moved-from
     assert(vs.empty()); // it was moved-from
-    assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
+    assert((m == M{{1, '4'}, {2, '3'}, {4, '2'}, {10, '1'}}));
   }
   {
     // flat_map(sorted_unique_t, key_container_type , mapped_container_type)
@@ -110,10 +110,10 @@ int main(int, char**) {
     using C              = test_less<int>;
     using M              = std::flat_map<int, char, C>;
     std::vector<int> ks  = {1, 2, 4, 10};
-    std::vector<char> vs = {4, 3, 2, 1};
+    std::vector<char> vs = {'4', '3', '2', '1'};
 
     auto m = M(std::sorted_unique, ks, vs, C(4));
-    assert((m == M{{1, 4}, {2, 3}, {4, 2}, {10, 1}}));
+    assert((m == M{{1, '4'}, {2, '3'}, {4, '2'}, {10, '1'}}));
     assert(m.key_comp() == C(4));
 
     // explicit(false)
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp
index 26452472ba201..14dab70ea569b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp
@@ -31,7 +31,7 @@
 #include "../../../test_compare.h"
 
 template <class T, class U>
-std::initializer_list<std::pair<T, U>> il = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+std::initializer_list<std::pair<T, U>> il = {{T{1}, U{1}}, {T{2}, U{2}}, {T{4}, U{4}}, {T{5}, U{5}}};
 
 const auto il1 = il<int, int>;
 const auto il2 = il<int, short>;
@@ -140,7 +140,7 @@ int main(int, char**) {
     using A2      = test_allocator<short>;
     using M       = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
     auto m        = M(std::sorted_unique, il2, A1(5));
-    auto expected = M{{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+    auto expected = M{{1, short{1}}, {2, short{2}}, {4, short{4}}, {5, short{5}}};
     assert(m == expected);
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
@@ -158,7 +158,7 @@ int main(int, char**) {
     using A2 = test_allocator<short>;
     using M  = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
     auto m   = M(std::sorted_unique, il2, C(3), A1(5));
-    assert((m == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
+    assert((m == M{{1, short{1}}, {2, short{2}}, {4, short{4}}, {5, short{5}}}));
     assert(m.key_comp() == C(3));
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
@@ -170,7 +170,7 @@ int main(int, char**) {
     using A2 = test_allocator<int>;
     using M  = std::flat_map<short, int, std::less<int>, std::deque<short, A1>, std::vector<int, A2>>;
     M m      = {std::sorted_unique, il3, {}, A1(5)}; // implicit ctor
-    assert((m == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
+    assert((m == M{{short{1}, 1}, {short{2}, 2}, {short{4}, 4}, {short{5}, 5}}));
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
   }
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
index 8eb7547e917cc..a5398cbc1a305 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp
@@ -125,10 +125,10 @@ int main(int, char**) {
     using A1      = test_allocator<int>;
     using A2      = test_allocator<short>;
     using M       = std::flat_map<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
-    using P       = std::pair<int, int>;
-    P ar[]        = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+    using P       = std::pair<int, short>;
+    P ar[]        = {{1, short{1}}, {2, short{2}}, {4, short{4}}, {5, short{5}}};
     auto m        = M(std::sorted_unique, ar, ar + 4, A1(5));
-    auto expected = M{{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+    auto expected = M{{1, short{1}}, {2, short{2}}, {4, short{4}}, {5, short{5}}};
     assert(m == expected);
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
@@ -145,10 +145,10 @@ int main(int, char**) {
     using A1 = test_allocator<int>;
     using A2 = test_allocator<short>;
     using M  = std::flat_map<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
-    using P  = std::pair<int, int>;
-    P ar[]   = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
+    using P  = std::pair<int, short>;
+    P ar[]   = {{1, short{1}}, {2, short{2}}, {4, short{4}}, {5, short{5}}};
     auto m   = M(std::sorted_unique, ar, ar + 4, C(3), A1(5));
-    assert((m == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
+    assert((m == M{{1, short{1}}, {2, short{2}}, {4, short{4}}, {5, short{5}}}));
     assert(m.key_comp() == C(3));
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
@@ -162,7 +162,7 @@ int main(int, char**) {
     using P  = std::pair<int, int>;
     P ar[]   = {{1, 1}, {2, 2}, {4, 4}, {5, 5}};
     M m      = {std::sorted_unique, ar, ar + 4, {}, A1(5)}; // implicit ctor
-    assert((m == M{{1, 1}, {2, 2}, {4, 4}, {5, 5}}));
+    assert((m == M{{short{1}, 1}, {short{2}, 2}, {short{4}, 4}, {short{5}, 5}}));
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
   }
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
index 48fdec42db3fc..c0e31dc38426c 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp
@@ -66,7 +66,8 @@ struct ErasurePredicate {
 };
 
 int main(int, char**) {
-  const std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}};
+  [[maybe_unused]] const std::pair<int, int> expected[] = {
+      {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}};
   {
     using M = std::flat_map<ThrowingAssignment, int, ThrowingComparator>;
     for (int first_throw = 1; first_throw < 99; ++first_throw) {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
index ef57b1cb5512d..d019c5eeaa1b9 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp
@@ -32,7 +32,7 @@ void test() {
   auto make = [](std::initializer_list<int> il) {
     M m;
     for (int i : il) {
-      m.emplace(i, i);
+      m.emplace(i, static_cast<char>(i));
     }
     return m;
   };
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/containers.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/containers.pass.cpp
index 17ee3c3864b1b..e21a0fcde8700 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/containers.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/containers.pass.cpp
@@ -69,9 +69,10 @@ int main(int, char**) {
     // flat_multimap(key_container_type , mapped_container_type)
     using M                         = std::flat_multimap<int, char>;
     std::vector<int> ks             = {1, 1, 1, 2, 2, 3, 2, 3, 3};
-    std::vector<char> vs            = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+    std::vector<char> vs            = {'1', '2', '3', '4', '5', '6', '7', '8', '9'};
     auto m                          = M(ks, vs);
-    std::pair<int, char> expected[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {2, 7}, {3, 6}, {3, 8}, {3, 9}};
+    std::pair<int, char> expected[] = {
+        {1, '1'}, {1, '2'}, {1, '3'}, {2, '4'}, {2, '5'}, {2, '7'}, {3, '6'}, {3, '8'}, {3, '9'}};
     assert(std::ranges::equal(m, expected));
 
     // explicit(false)
@@ -121,9 +122,10 @@ int main(int, char**) {
     using C                         = test_less<int>;
     using M                         = std::flat_multimap<int, char, C>;
     std::vector<int> ks             = {1, 1, 1, 2, 2, 3, 2, 3, 3};
-    std::vector<char> vs            = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+    std::vector<char> vs            = {'1', '2', '3', '4', '5', '6', '7', '8', '9'};
     auto m                          = M(ks, vs, C(4));
-    std::pair<int, char> expected[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {2, 7}, {3, 6}, {3, 8}, {3, 9}};
+    std::pair<int, char> expected[] = {
+        {1, '1'}, {1, '2'}, {1, '3'}, {2, '4'}, {2, '5'}, {2, '7'}, {3, '6'}, {3, '8'}, {3, '9'}};
     assert(std::ranges::equal(m, expected));
     assert(m.key_comp() == C(4));
 
@@ -163,13 +165,13 @@ int main(int, char**) {
   }
   {
     // flat_multimap(key_container_type , mapped_container_type, key_compare, const Allocator&)
-    using C                         = test_less<int>;
-    using A                         = test_allocator<int>;
-    using M                         = std::flat_multimap<int, int, C, std::vector<int, A>, std::vector<int, A>>;
-    std::vector<int, A> ks          = {1, 1, 1, 2, 2, 3, 2, 3, 3};
-    std::vector<int, A> vs          = {1, 2, 3, 4, 5, 6, 7, 8, 9};
-    auto m                          = M(ks, vs, C(4), A(5));
-    std::pair<int, char> expected[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {2, 7}, {3, 6}, {3, 8}, {3, 9}};
+    using C                        = test_less<int>;
+    using A                        = test_allocator<int>;
+    using M                        = std::flat_multimap<int, int, C, std::vector<int, A>, std::vector<int, A>>;
+    std::vector<int, A> ks         = {1, 1, 1, 2, 2, 3, 2, 3, 3};
+    std::vector<int, A> vs         = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+    auto m                         = M(ks, vs, C(4), A(5));
+    std::pair<int, int> expected[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {2, 7}, {3, 6}, {3, 8}, {3, 9}};
     assert(std::ranges::equal(m, expected));
     assert(m.key_comp() == C(4));
     assert(m.keys().get_allocator() == A(5));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/copy_assign.pass.cpp
index 3dd7ebdd38871..9dbdf94d0c413 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/copy_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/copy_assign.pass.cpp
@@ -26,10 +26,10 @@ int main(int, char**) {
     // test_allocator is not propagated
     using C = test_less<int>;
     std::vector<int, test_allocator<int>> ks({1, 1, 3, 3, 5}, test_allocator<int>(6));
-    std::vector<char, test_allocator<char>> vs({1, 2, 3, 4, 5}, test_allocator<char>(7));
+    std::vector<char, test_allocator<char>> vs({'1', '2', '3', '4', '5'}, test_allocator<char>(7));
     using M = std::flat_multimap<int, char, C, decltype(ks), decltype(vs)>;
     auto mo = M(ks, vs, C(5));
-    auto m  = M({{3, 3}, {4, 4}, {5, 5}}, C(3), test_allocator<int>(2));
+    auto m  = M({{3, '3'}, {4, '4'}, {5, '5'}}, C(3), test_allocator<int>(2));
     m       = mo;
 
     assert(m.key_comp() == C(5));
@@ -51,10 +51,10 @@ int main(int, char**) {
     using Ks = std::vector<int, other_allocator<int>>;
     using Vs = std::vector<char, other_allocator<char>>;
     auto ks  = Ks({1, 1, 3, 3, 5}, other_allocator<int>(6));
-    auto vs  = Vs({2, 1, 3, 2, 1}, other_allocator<char>(7));
+    auto vs  = Vs({'2', '1', '3', '2', '1'}, other_allocator<char>(7));
     using M  = std::flat_multimap<int, char, C, Ks, Vs>;
     auto mo  = M(Ks(ks, other_allocator<int>(6)), Vs(vs, other_allocator<int>(7)), C(5));
-    auto m   = M({{3, 3}, {4, 4}, {5, 5}}, C(3), other_allocator<int>(2));
+    auto m   = M({{3, '3'}, {4, '4'}, {5, '5'}}, C(3), other_allocator<int>(2));
     m        = mo;
 
     assert(m.key_comp() == C(5));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp
index a718d9cfad5b7..217f18e2106f4 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp
@@ -31,19 +31,19 @@ using PC = std::pair<const int, long>;
 
 void test_copy() {
   {
-    std::flat_multimap<long, short> source = {{1, 2}, {1, 3}};
+    std::flat_multimap<long, short> source = {{1, short{2}}, {1, short{3}}};
     std::flat_multimap s(source);
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s == source);
   }
   {
-    std::flat_multimap<long, short, std::greater<long>> source = {{1, 2}, {1, 3}};
+    std::flat_multimap<long, short, std::greater<long>> source = {{1, short{2}}, {1, short{3}}};
     std::flat_multimap s{source}; // braces instead of parens
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s == source);
   }
   {
-    std::flat_multimap<long, short, std::greater<long>> source = {{1, 2}, {1, 3}};
+    std::flat_multimap<long, short, std::greater<long>> source = {{1, short{2}}, {1, short{3}}};
     std::flat_multimap s(source, std::allocator<int>());
     ASSERT_SAME_TYPE(decltype(s), decltype(source));
     assert(s == source);
@@ -55,7 +55,8 @@ void test_containers() {
   std::deque<short, test_allocator<short>> vs({1, 2, 3, 4, 5, 3, 4}, test_allocator<int>(0, 43));
   std::deque<int, test_allocator<int>> sorted_ks({1, 1, 2, 2, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
   std::deque<short, test_allocator<short>> sorted_vs({1, 3, 2, 4, 5, 4, 3}, test_allocator<int>(0, 43));
-  const std::pair<int, short> expected[] = {{1, 1}, {1, 3}, {2, 2}, {2, 4}, {2, 5}, {3, 4}, {INT_MAX, 3}};
+  const std::pair<int, short> expected[] = {
+      {1, short{1}}, {1, short{3}}, {2, short{2}}, {2, short{4}}, {2, short{5}}, {3, short{4}}, {INT_MAX, short{3}}};
   {
     std::flat_multimap s(ks, vs);
 
@@ -95,7 +96,8 @@ void test_containers_compare() {
   std::deque<short, test_allocator<short>> vs({1, 2, 3, 4, 5, 3, 4}, test_allocator<int>(0, 43));
   std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 2, 2, 1, 1}, test_allocator<int>(0, 42));
   std::deque<short, test_allocator<short>> sorted_vs({3, 4, 2, 4, 5, 1, 3}, test_allocator<int>(0, 43));
-  const std::pair<int, short> expected[] = {{INT_MAX, 3}, {3, 4}, {2, 2}, {2, 4}, {2, 5}, {1, 1}, {1, 3}};
+  const std::pair<int, short> expected[] = {
+      {INT_MAX, short{3}}, {3, short{4}}, {2, short{2}}, {2, short{4}}, {2, short{5}}, {1, short{1}}, {1, short{3}}};
   {
     std::flat_multimap s(ks, vs, std::greater<int>());
 
@@ -280,8 +282,10 @@ void test_initializer_list_compare() {
 }
 
 void test_from_range() {
-  std::list<std::pair<int, short>> r     = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
-  const std::pair<int, short> expected[] = {{1, 1}, {1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};
+  std::list<std::pair<int, short>> r = {
+      {1, short{1}}, {2, short{2}}, {1, short{1}}, {INT_MAX, short{4}}, {3, short{5}}};
+  const std::pair<int, short> expected[] = {
+      {1, short{1}}, {1, short{1}}, {2, short{2}}, {3, short{5}}, {INT_MAX, short{4}}};
   {
     std::flat_multimap s(std::from_range, r);
     ASSERT_SAME_TYPE(decltype(s), std::flat_multimap<int, short, std::less<int>>);
@@ -303,8 +307,10 @@ void test_from_range() {
 }
 
 void test_from_range_compare() {
-  std::list<std::pair<int, short>> r     = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};
-  const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}, {1, 1}};
+  std::list<std::pair<int, short>> r = {
+      {1, short{1}}, {2, short{2}}, {1, short{1}}, {INT_MAX, short{4}}, {3, short{5}}};
+  const std::pair<int, short> expected[] = {
+      {INT_MAX, short{4}}, {3, short{5}}, {2, short{2}}, {1, short{1}}, {1, short{1}}};
   {
     std::flat_multimap s(std::from_range, r, std::greater<int>());
     ASSERT_SAME_TYPE(decltype(s), std::flat_multimap<int, short, std::greater<int>>);
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct_pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct_pmr.pass.cpp
index 1955a8806631b..2ce9e2610b504 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct_pmr.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct_pmr.pass.cpp
@@ -35,7 +35,8 @@ void test_containers() {
   std::deque<short, test_allocator<short>> vs({1, 2, 3, 4, 5, 3, 4}, test_allocator<int>(0, 43));
   std::deque<int, test_allocator<int>> sorted_ks({1, 1, 2, 2, 2, 3, INT_MAX}, test_allocator<int>(0, 42));
   std::deque<short, test_allocator<short>> sorted_vs({1, 3, 2, 4, 5, 4, 3}, test_allocator<int>(0, 43));
-  const std::pair<int, short> expected[] = {{1, 1}, {1, 3}, {2, 2}, {2, 4}, {2, 5}, {3, 4}, {INT_MAX, 3}};
+  const std::pair<int, short> expected[] = {
+      {1, short{1}}, {1, short{3}}, {2, short{2}}, {2, short{4}}, {2, short{5}}, {3, short{4}}, {INT_MAX, short{3}}};
   {
     std::pmr::monotonic_buffer_resource mr;
     std::pmr::monotonic_buffer_resource mr2;
@@ -69,7 +70,8 @@ void test_containers_compare() {
   std::deque<short, test_allocator<short>> vs({1, 2, 3, 4, 5, 3, 4}, test_allocator<int>(0, 43));
   std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 2, 2, 1, 1}, test_allocator<int>(0, 42));
   std::deque<short, test_allocator<short>> sorted_vs({3, 4, 2, 4, 5, 1, 3}, test_allocator<int>(0, 43));
-  const std::pair<int, short> expected[] = {{INT_MAX, 3}, {3, 4}, {2, 2}, {2, 4}, {2, 5}, {1, 1}, {1, 3}};
+  const std::pair<int, short> expected[] = {
+      {INT_MAX, short{3}}, {3, short{4}}, {2, short{2}}, {2, short{4}}, {2, short{5}}, {1, short{1}}, {1, short{3}}};
 
   {
     std::pmr::monotonic_buffer_resource mr;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/initializer_list.pass.cpp
index 8e89192ec0ea1..5be1c8e54c81a 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/initializer_list.pass.cpp
@@ -83,11 +83,13 @@ int main(int, char**) {
         !std::is_constructible_v<M, std::initializer_list<std::pair<const int, const short>>, std::allocator<int>>);
   }
 
-  std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {2, 2}, {3, 3}, {3, 3}, {5, 2}};
+  std::pair<int, short> expected[] = {
+      {1, short{1}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {3, short{3}}, {5, short{2}}};
   {
     // flat_multimap(initializer_list<value_type>);
     using M                                         = std::flat_multimap<int, short>;
-    std::initializer_list<std::pair<int, short>> il = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+    std::initializer_list<std::pair<int, short>> il = {
+        {5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}};
     M m(il);
     assert(std::ranges::equal(m, expected));
   }
@@ -95,13 +97,13 @@ int main(int, char**) {
     // flat_multimap(initializer_list<value_type>);
     // explicit(false)
     using M = std::flat_multimap<int, short>;
-    M m     = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+    M m     = {{5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}};
     assert(std::ranges::equal(m, expected));
   }
   {
     // flat_multimap(initializer_list<value_type>);
     using M = std::flat_multimap<int, short, std::greater<int>, std::deque<int, min_allocator<int>>>;
-    M m     = {{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}};
+    M m     = {{5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}};
     assert(std::equal(m.rbegin(), m.rend(), expected, expected + 6));
   }
   {
@@ -129,12 +131,12 @@ int main(int, char**) {
     // flat_multimap(initializer_list<value_type>, const key_compare&);
     using C = test_less<int>;
     using M = std::flat_multimap<int, short, C>;
-    auto m  = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, C(10));
+    auto m  = M({{5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}}, C(10));
     assert(std::ranges::equal(m, expected));
     assert(m.key_comp() == C(10));
 
     // explicit(false)
-    M m2 = {{{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, C(10)};
+    M m2 = {{{5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}}, C(10)};
     assert(m2 == m);
     assert(m2.key_comp() == C(10));
   }
@@ -142,7 +144,8 @@ int main(int, char**) {
     // flat_multimap(initializer_list<value_type>, const key_compare&);
     // Sorting uses the comparator that was passed in
     using M = std::flat_multimap<int, short, std::function<bool(int, int)>, std::deque<int, min_allocator<int>>>;
-    auto m  = M({{5, 2}, {2, 2}, {2, 2}, {3, 3}, {1, 1}, {3, 3}}, std::greater<int>());
+    auto m  = M({{5, short{2}}, {2, short{2}}, {2, short{2}}, {3, short{3}}, {1, short{1}}, {3, short{3}}},
+               std::greater<int>());
     assert(std::equal(m.rbegin(), m.rend(), expected, expected + 6));
     assert(m.key_comp()(2, 1) == true);
   }
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/iter_iter.pass.cpp
index c9c5e6c99d1c8..0db3e8e5851ba 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/iter_iter.pass.cpp
@@ -57,9 +57,27 @@ int main(int, char**) {
     static_assert(!std::is_constructible_v<M3, Iter3, Iter3, const C&, const A2&>);
   }
 
-  using P      = std::pair<int, short>;
-  P ar[]       = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
-  P expected[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {2, 7}, {3, 6}, {3, 8}, {3, 9}};
+  using P = std::pair<int, short>;
+  P ar[]  = {
+      {1, short{1}},
+      {1, short{2}},
+      {1, short{3}},
+      {2, short{4}},
+      {2, short{5}},
+      {3, short{6}},
+      {2, short{7}},
+      {3, short{8}},
+      {3, short{9}}};
+  P expected[] = {
+      {1, short{1}},
+      {1, short{2}},
+      {1, short{3}},
+      {2, short{4}},
+      {2, short{5}},
+      {2, short{7}},
+      {3, short{6}},
+      {3, short{8}},
+      {3, short{9}}};
   {
     // flat_multimap(InputIterator , InputIterator)
     // cpp17_input_iterator
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign.pass.cpp
index 38200d008c78a..86e7cdd433de6 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign.pass.cpp
@@ -32,10 +32,10 @@ int main(int, char**) {
     using A1 = test_allocator<int>;
     using A2 = test_allocator<char>;
     using M  = std::flat_multimap<int, char, C, std::vector<int, A1>, std::vector<char, A2>>;
-    M mo     = M({{1, 1}, {1, 3}, {3, 2}}, C(5), A1(7));
+    M mo     = M({{1, '1'}, {1, '3'}, {3, '2'}}, C(5), A1(7));
     M m      = M({}, C(3), A1(7));
     m        = std::move(mo);
-    assert((m == M{{1, 1}, {1, 3}, {3, 2}}));
+    assert((m == M{{1, '1'}, {1, '3'}, {3, '2'}}));
     assert(m.key_comp() == C(5));
     auto [ks, vs] = std::move(m).extract();
     assert(ks.get_allocator() == A1(7));
@@ -47,10 +47,10 @@ int main(int, char**) {
     using A1 = other_allocator<int>;
     using A2 = other_allocator<char>;
     using M  = std::flat_multimap<int, char, C, std::deque<int, A1>, std::deque<char, A2>>;
-    M mo     = M({{4, 5}, {4, 4}}, C(5), A1(7));
-    M m      = M({{1, 1}, {1, 2}, {1, 3}, {4, 4}}, C(3), A1(7));
+    M mo     = M({{4, '5'}, {4, '4'}}, C(5), A1(7));
+    M m      = M({{1, '1'}, {1, '2'}, {1, '3'}, {4, '4'}}, C(3), A1(7));
     m        = std::move(mo);
-    assert((m == M{{4, 5}, {4, 4}}));
+    assert((m == M{{4, '5'}, {4, '4'}}));
     assert(m.key_comp() == C(5));
     auto [ks, vs] = std::move(m).extract();
     assert(ks.get_allocator() == A1(7));
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/pmr.pass.cpp
index 8b518f6afbda9..7b75c5d57be23 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/pmr.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/pmr.pass.cpp
@@ -166,9 +166,27 @@ int main(int, char**) {
   }
   {
     // flat_multimap(InputIterator first, InputIterator last, const Allocator& a);
-    using P      = std::pair<int, short>;
-    P ar[]       = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
-    P expected[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {2, 7}, {3, 6}, {3, 8}, {3, 9}};
+    using P = std::pair<int, short>;
+    P ar[]  = {
+        {1, short{1}},
+        {1, short{2}},
+        {1, short{3}},
+        {2, short{4}},
+        {2, short{5}},
+        {3, short{6}},
+        {2, short{7}},
+        {3, short{8}},
+        {3, short{9}}};
+    P expected[] = {
+        {1, short{1}},
+        {1, short{2}},
+        {1, short{3}},
+        {2, short{4}},
+        {2, short{5}},
+        {2, short{7}},
+        {3, short{6}},
+        {3, short{8}},
+        {3, short{9}}};
     {
       //  cpp17 iterator
       using M = std::flat_multimap<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
@@ -242,9 +260,27 @@ int main(int, char**) {
   }
   {
     //  flat_multimap(from_range_t, R&&, const Alloc&);
-    using P      = std::pair<int, short>;
-    P ar[]       = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
-    P expected[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {2, 7}, {3, 6}, {3, 8}, {3, 9}};
+    using P = std::pair<int, short>;
+    P ar[]  = {
+        {1, short{1}},
+        {1, short{2}},
+        {1, short{3}},
+        {2, short{4}},
+        {2, short{5}},
+        {3, short{6}},
+        {2, short{7}},
+        {3, short{8}},
+        {3, short{9}}};
+    P expected[] = {
+        {1, short{1}},
+        {1, short{2}},
+        {1, short{3}},
+        {2, short{4}},
+        {2, short{5}},
+        {2, short{7}},
+        {3, short{6}},
+        {3, short{8}},
+        {3, short{9}}};
     {
       // input_range
       using M    = std::flat_multimap<int, short, std::less<int>, std::pmr::vector<int>, std::pmr::vector<short>>;
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/range.pass.cpp
index de750e2506341..542b517eeebd2 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/range.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/range.pass.cpp
@@ -117,9 +117,27 @@ int main(int, char**) {
     static_assert(!std::is_constructible_v<M, std::from_range_t, std::vector<NonPairLike>&, const C&, const A1&>);
   }
 
-  using P      = std::pair<int, short>;
-  P ar[]       = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {3, 6}, {2, 7}, {3, 8}, {3, 9}};
-  P expected[] = {{1, 1}, {1, 2}, {1, 3}, {2, 4}, {2, 5}, {2, 7}, {3, 6}, {3, 8}, {3, 9}};
+  using P = std::pair<int, short>;
+  P ar[]  = {
+      {1, short{1}},
+      {1, short{2}},
+      {1, short{3}},
+      {2, short{4}},
+      {2, short{5}},
+      {3, short{6}},
+      {2, short{7}},
+      {3, short{8}},
+      {3, short{9}}};
+  P expected[] = {
+      {1, short{1}},
+      {1, short{2}},
+      {1, short{3}},
+      {2, short{4}},
+      {2, short{5}},
+      {2, short{7}},
+      {3, short{6}},
+      {3, short{8}},
+      {3, short{9}}};
   {
     // flat_multimap(from_range_t, R&&)
     // input_range && !common
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_container.pass.cpp
index 16579f0deed5d..518904801f2bd 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_container.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_container.pass.cpp
@@ -61,16 +61,16 @@ int main(int, char**) {
     // flat_multimap(sorted_equivalent_t, key_container_type , mapped_container_type)
     using M              = std::flat_multimap<int, char>;
     std::vector<int> ks  = {1, 4, 4, 10};
-    std::vector<char> vs = {4, 3, 2, 1};
+    std::vector<char> vs = {'4', '3', '2', '1'};
     auto ks2             = ks;
     auto vs2             = vs;
 
     auto m = M(std::sorted_equivalent, ks, vs);
-    assert((m == M{{1, 4}, {4, 3}, {4, 2}, {10, 1}}));
+    assert((m == M{{1, '4'}, {4, '3'}, {4, '2'}, {10, '1'}}));
     m = M(std::sorted_equivalent, std::move(ks), std::move(vs));
     assert(ks.empty()); // it was moved-from
     assert(vs.empty()); // it was moved-from
-    assert((m == M{{1, 4}, {4, 3}, {4, 2}, {10, 1}}));
+    assert((m == M{{1, '4'}, {4, '3'}, {4, '2'}, {10, '1'}}));
 
     // explicit(false)
     M m2 = {std::sorted_equivalent, std::move(ks2), std::move(vs2)};
@@ -83,13 +83,13 @@ int main(int, char**) {
     using Vs = std::deque<char, min_allocator<char>>;
     using M  = std::flat_multimap<int, char, std::greater<int>, Ks, Vs>;
     Ks ks    = {10, 1, 1, 1};
-    Vs vs    = {1, 2, 3, 4};
+    Vs vs    = {'1', '2', '3', '4'};
     auto m   = M(std::sorted_equivalent, ks, vs);
-    assert((m == M{{1, 2}, {1, 3}, {1, 4}, {10, 1}}));
+    assert((m == M{{1, '2'}, {1, '3'}, {1, '4'}, {10, '1'}}));
     m = M(std::sorted_equivalent, std::move(ks), std::move(vs));
     assert(ks.empty()); // it was moved-from
     assert(vs.empty()); // it was moved-from
-    assert((m == M{{1, 2}, {1, 3}, {1, 4}, {10, 1}}));
+    assert((m == M{{1, '2'}, {1, '3'}, {1, '4'}, {10, '1'}}));
   }
   {
     // flat_multimap(sorted_equivalent_t, key_container_type , mapped_container_type)
@@ -110,10 +110,10 @@ int main(int, char**) {
     using C              = test_less<int>;
     using M              = std::flat_multimap<int, char, C>;
     std::vector<int> ks  = {1, 2, 10, 10};
-    std::vector<char> vs = {4, 3, 2, 1};
+    std::vector<char> vs = {'4', '3', '2', '1'};
 
     auto m = M(std::sorted_equivalent, ks, vs, C(4));
-    assert((m == M{{1, 4}, {2, 3}, {10, 2}, {10, 1}}));
+    assert((m == M{{1, '4'}, {2, '3'}, {10, '2'}, {10, '1'}}));
     assert(m.key_comp() == C(4));
 
     // explicit(false)
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_initializer_list.pass.cpp
index b34313bb3d404..89c7119da389b 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_initializer_list.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_initializer_list.pass.cpp
@@ -31,7 +31,7 @@
 #include "../../../test_compare.h"
 
 template <class T, class U>
-std::initializer_list<std::pair<T, U>> il = {{1, 1}, {4, 2}, {4, 4}, {5, 5}};
+std::initializer_list<std::pair<T, U>> il = {{T{1}, U{1}}, {T{4}, U{2}}, {T{4}, U{4}}, {T{5}, U{5}}};
 
 const auto il1 = il<int, int>;
 const auto il2 = il<int, short>;
@@ -144,7 +144,7 @@ int main(int, char**) {
     using A2      = test_allocator<short>;
     using M       = std::flat_multimap<int, short, std::less<int>, std::vector<int, A1>, std::deque<short, A2>>;
     auto m        = M(std::sorted_equivalent, il2, A1(5));
-    auto expected = M{{1, 1}, {4, 2}, {4, 4}, {5, 5}};
+    auto expected = M{{1, short{1}}, {4, short{2}}, {4, short{4}}, {5, short{5}}};
     assert(m == expected);
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
@@ -162,7 +162,7 @@ int main(int, char**) {
     using A2 = test_allocator<short>;
     using M  = std::flat_multimap<int, short, C, std::vector<int, A1>, std::deque<short, A2>>;
     auto m   = M(std::sorted_equivalent, il2, C(3), A1(5));
-    assert((m == M{{1, 1}, {4, 2}, {4, 4}, {5, 5}}));
+    assert((m == M{{1, short{1}}, {4, short{2}}, {4, short{4}}, {5, short{5}}}));
     assert(m.key_comp() == C(3));
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
@@ -174,7 +174,7 @@ int main(int, char**) {
     using A2 = test_allocator<int>;
     using M  = std::flat_multimap<short, int, std::less<int>, std::deque<short, A1>, std::vector<int, A2>>;
     M m      = {std::sorted_equivalent, il3, {}, A1(5)}; // implicit ctor
-    assert((m == M{{1, 1}, {4, 2}, {4, 4}, {5, 5}}));
+    assert((m == M{{short{1}, 1}, {short{4}, 2}, {short{4}, 4}, {short{5}, 5}}));
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
   }
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_iter_iter.pass.cpp
index 45c4b3dc675a5..5f532c435c797 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_iter_iter.pass.cpp
@@ -130,7 +130,7 @@ int main(int, char**) {
     using P       = std::pair<int, int>;
     P ar[]        = {{2, 1}, {2, 2}, {4, 4}, {5, 5}};
     auto m        = M(std::sorted_equivalent, ar, ar + 4, A1(5));
-    auto expected = M{{2, 1}, {2, 2}, {4, 4}, {5, 5}};
+    auto expected = M{{2, short{1}}, {2, short{2}}, {4, short{4}}, {5, short{5}}};
     assert(m == expected);
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
@@ -150,7 +150,7 @@ int main(int, char**) {
     using P  = std::pair<int, int>;
     P ar[]   = {{1, 1}, {1, 2}, {1, 4}, {1, 5}};
     auto m   = M(std::sorted_equivalent, ar, ar + 4, C(3), A1(5));
-    assert((m == M{{1, 1}, {1, 2}, {1, 4}, {1, 5}}));
+    assert((m == M{{1, short{1}}, {1, short{2}}, {1, short{4}}, {1, short{5}}}));
     assert(m.key_comp() == C(3));
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
@@ -161,10 +161,10 @@ int main(int, char**) {
     using A1 = test_allocator<short>;
     using A2 = test_allocator<int>;
     using M  = std::flat_multimap<short, int, std::less<int>, std::deque<short, A1>, std::vector<int, A2>>;
-    using P  = std::pair<int, int>;
-    P ar[]   = {{1, 1}, {1, 2}, {1, 4}, {1, 5}};
+    using P  = std::pair<short, int>;
+    P ar[]   = {{short{1}, 1}, {short{1}, 2}, {short{1}, 4}, {short{1}, 5}};
     M m      = {std::sorted_equivalent, ar, ar + 4, {}, A1(5)}; // implicit ctor
-    assert((m == M{{1, 1}, {1, 2}, {1, 4}, {1, 5}}));
+    assert((m == M{{short{1}, 1}, {short{1}, 2}, {short{1}, 4}, {short{1}, 5}}));
     assert(m.keys().get_allocator() == A1(5));
     assert(m.values().get_allocator() == A2(5));
   }
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.erasure/erase_if_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.erasure/erase_if_exceptions.pass.cpp
index 13b57202f7862..95f7e11626a4e 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.erasure/erase_if_exceptions.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.erasure/erase_if_exceptions.pass.cpp
@@ -68,7 +68,8 @@ struct ErasurePredicate {
 };
 
 int main(int, char**) {
-  const std::pair<int, int> expected[] = {{1, 1}, {2, 2}, {3, 3}, {3, 3}, {5, 5}, {6, 6}, {7, 7}, {8, 8}};
+  [[maybe_unused]] const std::pair<int, int> expected[] = {
+      {1, 1}, {2, 2}, {3, 3}, {3, 3}, {5, 5}, {6, 6}, {7, 7}, {8, 8}};
   {
     using M = std::flat_multimap<ThrowingAssignment, int, ThrowingComparator>;
     for (int first_throw = 1; first_throw < 99; ++first_throw) {
diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp
index 7944996fba1a0..b9624d45a8041 100644
--- a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp
+++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp
@@ -34,7 +34,7 @@ void test() {
   auto make = [](std::initializer_list<int> il) {
     M m;
     for (int i : il) {
-      m.emplace(i, i);
+      m.emplace(i, static_cast<char>(i));
     }
     return m;
   };