Fix set/ final tests

vinay-deshmukh · vinay-deshmukh · commit 7ce7dcdba372 · 2025-11-09T21:10:14.000-05:00
diff --git a/libcxx/include/__node_handle b/libcxx/include/__node_handle
@@ -172,7 +172,9 @@ template <class _NodeType, class _Derived>
 struct __set_node_handle_specifics {
   typedef typename _NodeType::__node_value_type value_type;
 
-  _LIBCPP_HIDE_FROM_ABI value_type& value() const { return static_cast<_Derived const*>(this)->__ptr_->__get_value(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 value_type& value() const {
+    return static_cast<_Derived const*>(this)->__ptr_->__get_value();
+  }
 };
 
 template <class _NodeType, class _Derived>
diff --git a/libcxx/test/std/containers/associative/set/contains.pass.cpp b/libcxx/test/std/containers/associative/set/contains.pass.cpp
@@ -11,12 +11,14 @@
 #include <cassert>
 #include <set>
 
+#include "test_macros.h"
+
 // <set>
 
 // constexpr bool contains(const key_type& x) const; // constexpr since C++26
 
 template <typename T, typename V, typename B, typename... Vals>
-void test(B bad, Vals... args) {
+TEST_CONSTEXPR_CXX26 void test(B bad, Vals... args) {
   T set;
   V vals[] = {args...};
 
@@ -39,7 +41,7 @@ TEST_CONSTEXPR_CXX26 bool test() {
     test<std::set<int>, int>(14, 10, 11, 12, 13);
     test<std::set<char>, char>('e', 'a', 'b', 'c', 'd');
   }
-  {
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     test<std::multiset<int>, int>(14, 10, 11, 12, 13);
     test<std::multiset<char>, char>('e', 'a', 'b', 'c', 'd');
   }
diff --git a/libcxx/test/std/containers/associative/set/contains_transparent.pass.cpp b/libcxx/test/std/containers/associative/set/contains_transparent.pass.cpp
@@ -18,18 +18,22 @@
 #include <set>
 #include <utility>
 
+#include "test_macros.h"
+
 struct Comp {
   using is_transparent = void;
 
-  bool operator()(const std::pair<int, int>& lhs, const std::pair<int, int>& rhs) const { return lhs < rhs; }
+  TEST_CONSTEXPR_CXX26 bool operator()(const std::pair<int, int>& lhs, const std::pair<int, int>& rhs) const {
+    return lhs < rhs;
+  }
 
-  bool operator()(const std::pair<int, int>& lhs, int rhs) const { return lhs.first < rhs; }
+  TEST_CONSTEXPR_CXX26 bool operator()(const std::pair<int, int>& lhs, int rhs) const { return lhs.first < rhs; }
 
-  bool operator()(int lhs, const std::pair<int, int>& rhs) const { return lhs < rhs.first; }
+  TEST_CONSTEXPR_CXX26 bool operator()(int lhs, const std::pair<int, int>& rhs) const { return lhs < rhs.first; }
 };
 
 template <typename Container>
-void test() {
+TEST_CONSTEXPR_CXX26 void test() {
   Container s{{2, 1}, {1, 2}, {1, 3}, {1, 4}, {2, 2}};
 
   assert(s.contains(1));
@@ -38,7 +42,8 @@ void test() {
 
 TEST_CONSTEXPR_CXX26 bool test() {
   test<std::set<std::pair<int, int>, Comp> >();
-  test<std::multiset<std::pair<int, int>, Comp> >();
+  if (!TEST_IS_CONSTANT_EVALUATED)
+    test<std::multiset<std::pair<int, int>, Comp> >();
 
   return true;
 }
diff --git a/libcxx/test/std/containers/associative/set/count_transparent.pass.cpp b/libcxx/test/std/containers/associative/set/count_transparent.pass.cpp
@@ -19,14 +19,18 @@
 #include <set>
 #include <utility>
 
+#include "test_macros.h"
+
 struct Comp {
   using is_transparent = void;
 
-  bool operator()(const std::pair<int, int>& lhs, const std::pair<int, int>& rhs) const { return lhs < rhs; }
+  TEST_CONSTEXPR_CXX26 bool operator()(const std::pair<int, int>& lhs, const std::pair<int, int>& rhs) const {
+    return lhs < rhs;
+  }
 
-  bool operator()(const std::pair<int, int>& lhs, int rhs) const { return lhs.first < rhs; }
+  TEST_CONSTEXPR_CXX26 bool operator()(const std::pair<int, int>& lhs, int rhs) const { return lhs.first < rhs; }
 
-  bool operator()(int lhs, const std::pair<int, int>& rhs) const { return lhs < rhs.first; }
+  TEST_CONSTEXPR_CXX26 bool operator()(int lhs, const std::pair<int, int>& rhs) const { return lhs < rhs.first; }
 };
 
 TEST_CONSTEXPR_CXX26 bool test() {
diff --git a/libcxx/test/std/containers/associative/set/emplace.pass.cpp b/libcxx/test/std/containers/associative/set/emplace.pass.cpp
@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 
 TEST_CONSTEXPR_CXX26 bool test() {
-  {
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     typedef std::set<DefaultOnly> M;
     typedef std::pair<M::iterator, bool> R;
     M m;
@@ -43,7 +43,8 @@ TEST_CONSTEXPR_CXX26 bool test() {
     assert(*m.begin() == DefaultOnly());
     assert(DefaultOnly::count == 1);
   }
-  assert(DefaultOnly::count == 0);
+  if (!TEST_IS_CONSTANT_EVALUATED)
+    assert(DefaultOnly::count == 0);
   {
     typedef std::set<Emplaceable> M;
     typedef std::pair<M::iterator, bool> R;
diff --git a/libcxx/test/std/containers/associative/set/emplace_hint.pass.cpp b/libcxx/test/std/containers/associative/set/emplace_hint.pass.cpp
@@ -24,7 +24,7 @@
 #include "min_allocator.h"
 
 TEST_CONSTEXPR_CXX26 bool test() {
-  {
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     typedef std::set<DefaultOnly> M;
     typedef M::iterator R;
     M m;
@@ -41,7 +41,8 @@ TEST_CONSTEXPR_CXX26 bool test() {
     assert(*m.begin() == DefaultOnly());
     assert(DefaultOnly::count == 1);
   }
-  assert(DefaultOnly::count == 0);
+  if (!TEST_IS_CONSTANT_EVALUATED)
+    assert(DefaultOnly::count == 0);
   {
     typedef std::set<Emplaceable> M;
     typedef M::iterator R;
diff --git a/libcxx/test/std/containers/associative/set/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/associative/set/equal_range_transparent.pass.cpp
@@ -23,14 +23,18 @@
 #include <set>
 #include <utility>
 
+#include "test_macros.h"
+
 struct Comp {
   using is_transparent = void;
 
-  bool operator()(const std::pair<int, int>& lhs, const std::pair<int, int>& rhs) const { return lhs < rhs; }
+  TEST_CONSTEXPR_CXX26 bool operator()(const std::pair<int, int>& lhs, const std::pair<int, int>& rhs) const {
+    return lhs < rhs;
+  }
 
-  bool operator()(const std::pair<int, int>& lhs, int rhs) const { return lhs.first < rhs; }
+  TEST_CONSTEXPR_CXX26 bool operator()(const std::pair<int, int>& lhs, int rhs) const { return lhs.first < rhs; }
 
-  bool operator()(int lhs, const std::pair<int, int>& rhs) const { return lhs < rhs.first; }
+  TEST_CONSTEXPR_CXX26 bool operator()(int lhs, const std::pair<int, int>& rhs) const { return lhs < rhs.first; }
 };
 
 TEST_CONSTEXPR_CXX26 bool test() {
diff --git a/libcxx/test/std/containers/associative/set/erase_iter.pass.cpp b/libcxx/test/std/containers/associative/set/erase_iter.pass.cpp
@@ -20,10 +20,10 @@
 
 struct TemplateConstructor {
   template <typename T>
-  TemplateConstructor(const T&) {}
+  TEST_CONSTEXPR_CXX26 TemplateConstructor(const T&) {}
 };
 
-bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
+TEST_CONSTEXPR_CXX26 bool operator<(const TemplateConstructor&, const TemplateConstructor&) { return false; }
 
 TEST_CONSTEXPR_CXX26 bool test() {
   {
diff --git a/libcxx/test/std/containers/associative/set/extract_iterator.pass.cpp b/libcxx/test/std/containers/associative/set/extract_iterator.pass.cpp
@@ -20,7 +20,7 @@
 #include "Counter.h"
 
 template <class Container>
-void test(Container& c) {
+TEST_CONSTEXPR_CXX26 void test(Container& c) {
   std::size_t sz = c.size();
 
   for (auto first = c.cbegin(); first != c.cend();) {
@@ -42,7 +42,7 @@ TEST_CONSTEXPR_CXX26 bool test() {
     test(m);
   }
 
-  {
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     std::set<Counter<int>> m = {1, 2, 3, 4, 5, 6};
     assert(Counter_base::gConstructed == 6);
     test(m);
diff --git a/libcxx/test/std/containers/associative/set/extract_key.pass.cpp b/libcxx/test/std/containers/associative/set/extract_key.pass.cpp
@@ -20,7 +20,7 @@
 #include "Counter.h"
 
 template <class Container, class KeyTypeIter>
-void test(Container& c, KeyTypeIter first, KeyTypeIter last) {
+TEST_CONSTEXPR_CXX26 void test(Container& c, KeyTypeIter first, KeyTypeIter last) {
   std::size_t sz = c.size();
   assert((std::size_t)std::distance(first, last) == sz);
 
@@ -48,7 +48,7 @@ TEST_CONSTEXPR_CXX26 bool test() {
     test(m, std::begin(keys), std::end(keys));
   }
 
-  {
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     std::set<Counter<int>> m = {1, 2, 3, 4, 5, 6};
     {
       Counter<int> keys[] = {1, 2, 3, 4, 5, 6};
diff --git a/libcxx/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp b/libcxx/test/std/containers/associative/set/insert_and_emplace_allocator_requirements.pass.cpp
@@ -10,9 +10,9 @@
 
 // class set
 
-// constexpr insert(...) // constexpr since C++26
-// constexpr emplace(...) // constexpr since C++26
-// constexpr emplace_hint(...) // constexpr since C++26
+// insert(...)
+// emplace(...)
+// emplace_hint(...)
 
 // UNSUPPORTED: c++03
 
@@ -21,17 +21,10 @@
 #include "container_test_types.h"
 #include "../../set_allocator_requirement_test_templates.h"
 
-TEST_CONSTEXPR_CXX26 bool test() {
+int main(int, char**) {
   testSetInsert<TCT::set<> >();
   testSetEmplace<TCT::set<> >();
   testSetEmplaceHint<TCT::set<> >();
 
-  return true;
-}
-int main(int, char**) {
-  test();
-#if TEST_STD_VER >= 26
-  static_assert(test());
-#endif
   return 0;
 }
diff --git a/libcxx/test/std/containers/associative/set/insert_cv.pass.cpp b/libcxx/test/std/containers/associative/set/insert_cv.pass.cpp
@@ -19,7 +19,7 @@
 #include "min_allocator.h"
 
 template <class Container>
-void do_insert_cv_test() {
+TEST_CONSTEXPR_CXX26 void do_insert_cv_test() {
   typedef Container M;
   typedef std::pair<typename M::iterator, bool> R;
   typedef typename M::value_type VT;
diff --git a/libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp
@@ -21,7 +21,7 @@
 #include "test_iterators.h"
 
 template <class Iter, class Alloc>
-void test_alloc() {
+TEST_CONSTEXPR_CXX26 void test_alloc() {
   {   // Check that an empty range works correctly
     { // Without elements in the container
       using Map = std::set<int, std::less<int>, Alloc>;
@@ -178,13 +178,9 @@ void test_alloc() {
   }
 }
 
-void test() {
+TEST_CONSTEXPR_CXX26 bool test() {
   test_alloc<cpp17_input_iterator<int*>, std::allocator<int> >();
   test_alloc<cpp17_input_iterator<int*>, min_allocator<int> >();
-}
-
-TEST_CONSTEXPR_CXX26 bool test() {
-  test();
 
   return true;
 }
diff --git a/libcxx/test/std/containers/associative/set/insert_node_type.pass.cpp b/libcxx/test/std/containers/associative/set/insert_node_type.pass.cpp
@@ -21,7 +21,7 @@
 #include "min_allocator.h"
 
 template <class Container, class T>
-void verify_insert_return_type(T&& t) {
+TEST_CONSTEXPR_CXX26 void verify_insert_return_type(T&& t) {
   using verified_type = std::remove_cv_t<std::remove_reference_t<T>>;
   static_assert(std::is_aggregate_v<verified_type>);
   static_assert(std::is_same_v<verified_type, typename Container::insert_return_type>);
@@ -42,19 +42,20 @@ void verify_insert_return_type(T&& t) {
 }
 
 template <class Container>
-typename Container::node_type node_factory(typename Container::key_type const& key) {
-  static Container c;
+TEST_CONSTEXPR_CXX26 typename Container::node_type node_factory(Container& c, typename Container::key_type const& key) {
   auto p = c.insert(key);
   assert(p.second);
   return c.extract(p.first);
 }
 
 template <class Container>
-void test(Container& c) {
+TEST_CONSTEXPR_CXX26 void test(Container& c) {
   auto* nf = &node_factory<Container>;
 
+  Container c2;
+
   for (int i = 0; i != 10; ++i) {
-    typename Container::node_type node = nf(i);
+    typename Container::node_type node = nf(c2, i);
     assert(!node.empty());
     typename Container::insert_return_type irt = c.insert(std::move(node));
     assert(node.empty());
@@ -77,7 +78,7 @@ void test(Container& c) {
   }
 
   { // Insert duplicate node.
-    typename Container::node_type dupl = nf(0);
+    typename Container::node_type dupl = nf(c2, 0);
     auto irt                           = c.insert(std::move(dupl));
     assert(dupl.empty());
     assert(!irt.inserted);
diff --git a/libcxx/test/std/containers/associative/set/insert_node_type_hint.pass.cpp b/libcxx/test/std/containers/associative/set/insert_node_type_hint.pass.cpp
@@ -19,19 +19,20 @@
 #include "min_allocator.h"
 
 template <class Container>
-typename Container::node_type node_factory(typename Container::key_type const& key) {
-  static Container c;
+TEST_CONSTEXPR_CXX26 typename Container::node_type node_factory(Container& c, typename Container::key_type const& key) {
   auto p = c.insert(key);
   assert(p.second);
   return c.extract(p.first);
 }
 
 template <class Container>
-void test(Container& c) {
+TEST_CONSTEXPR_CXX26 void test(Container& c) {
   auto* nf = &node_factory<Container>;
 
+  Container c2;
+
   for (int i = 0; i != 10; ++i) {
-    typename Container::node_type node = nf(i);
+    typename Container::node_type node = nf(c2, i);
     assert(!node.empty());
     std::size_t prev = c.size();
     auto it          = c.insert(c.end(), std::move(node));
diff --git a/libcxx/test/std/containers/associative/set/insert_range.pass.cpp b/libcxx/test/std/containers/associative/set/insert_range.pass.cpp
@@ -9,6 +9,7 @@
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 // Some fields in the test case variables are deliberately not explicitly initialized, this silences a warning on GCC.
 // ADDITIONAL_COMPILE_FLAGS(gcc-style-warnings): -Wno-missing-field-initializers
+// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=2147483647
 
 // <set>
 
diff --git a/libcxx/test/std/containers/associative/set/merge.pass.cpp b/libcxx/test/std/containers/associative/set/merge.pass.cpp
@@ -27,7 +27,7 @@
 #include "Counter.h"
 
 template <class Set>
-bool set_equal(const Set& set, Set other) {
+TEST_CONSTEXPR_CXX26 bool set_equal(const Set& set, Set other) {
   return set == other;
 }
 
@@ -55,8 +55,8 @@ TEST_CONSTEXPR_CXX26 bool test() {
     assert(set_equal(dst, {1, 2, 3, 4, 5}));
   }
 
-#ifndef TEST_HAS_NO_EXCEPTIONS
-  {
+#if !defined(TEST_HAS_NO_EXCEPTIONS)
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     bool do_throw = false;
     typedef std::set<Counter<int>, throw_comparator> set_type;
     set_type src({1, 3, 5}, throw_comparator(do_throw));
@@ -75,13 +75,14 @@ TEST_CONSTEXPR_CXX26 bool test() {
     assert(set_equal(dst, set_type({2, 4, 5}, throw_comparator(do_throw))));
   }
 #endif
-  assert(Counter_base::gConstructed == 0);
+  if (!TEST_IS_CONSTANT_EVALUATED)
+    assert(Counter_base::gConstructed == 0);
   struct comparator {
     comparator() = default;
 
     bool operator()(const Counter<int>& lhs, const Counter<int>& rhs) const { return lhs < rhs; }
   };
-  {
+  if (!TEST_IS_CONSTANT_EVALUATED) {
     typedef std::set<Counter<int>, std::less<Counter<int>>> first_set_type;
     typedef std::set<Counter<int>, comparator> second_set_type;
     typedef std::multiset<Counter<int>, comparator> third_set_type;
@@ -128,7 +129,7 @@ TEST_CONSTEXPR_CXX26 bool test() {
       first.merge(second);
       first.merge(std::move(second));
     }
-    {
+    if (!TEST_IS_CONSTANT_EVALUATED) {
       std::multiset<int> second;
       first.merge(second);
       first.merge(std::move(second));
diff --git a/libcxx/test/std/containers/insert_range_maps_sets.h b/libcxx/test/std/containers/insert_range_maps_sets.h
diff --git a/libcxx/test/std/containers/set_allocator_requirement_test_templates.h b/libcxx/test/std/containers/set_allocator_requirement_test_templates.h

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@`
`20`	`20`	`#include "Counter.h"`
`21`	`21`
`22`	`22`	`template <class Container, class KeyTypeIter>`
`23`		`-void test(Container& c, KeyTypeIter first, KeyTypeIter last) {`
	`23`	`+TEST_CONSTEXPR_CXX26 void test(Container& c, KeyTypeIter first, KeyTypeIter last) {`
`24`	`24`	`std::size_t sz = c.size();`
`25`	`25`	`assert((std::size_t)std::distance(first, last) == sz);`
`26`	`26`
`@@ -48,7 +48,7 @@ TEST_CONSTEXPR_CXX26 bool test() {`
`48`	`48`	`test(m, std::begin(keys), std::end(keys));`
`49`	`49`	`}`
`50`	`50`
`51`		`- {`
	`51`	`+ if (!TEST_IS_CONSTANT_EVALUATED) {`
`52`	`52`	`std::set<Counter<int>> m = {1, 2, 3, 4, 5, 6};`
`53`	`53`	`{`
`54`	`54`	`Counter<int> keys[] = {1, 2, 3, 4, 5, 6};`