Use std::as_const pattern for all tests

Author: smallp-o-p

libcxx/test/std/utilities/optional/optional.iterator/begin.pass.cpp

@@ -11,7 +11,7 @@
 // <optional>
 
 // constexpr iterator optional::begin() noexcept;
-// constexpr const_iterator optional::begin() noexcept;
+// constexpr const_iterator optional::begin() const noexcept;
 
 #include <cassert>
 #include <iterator>
@@ -21,21 +21,20 @@
 
 template <typename T>
 constexpr bool test() {
-  const std::optional<T> opt{T{}};
-  std::optional<T> nonconst_opt{T{}};
+  std::optional<T> opt{T{}};
 
   { // begin() is marked noexcept
     static_assert(noexcept(opt.begin()));
-    static_assert(noexcept(nonconst_opt.begin()));
+    static_assert(noexcept(std::as_const(opt).begin()));
   }
 
   { // Dereferencing an iterator at the beginning == indexing the 0th element, and that calling begin() again return the same iterator.
     auto iter1 = opt.begin();
-    auto iter2 = nonconst_opt.begin();
+    auto iter2 = std::as_const(opt).begin();
     assert(*iter1 == iter1[0]);
     assert(*iter2 == iter2[0]);
     assert(iter1 == opt.begin());
-    assert(iter2 == nonconst_opt.begin());
+    assert(iter2 == std::as_const(opt).begin());
   }
 
   { // Calling begin() multiple times on a disengaged optional returns the same iterator.

libcxx/test/std/utilities/optional/optional.iterator/end.pass.cpp

@@ -11,48 +11,47 @@
 // <optional>
 
 // constexpr iterator optional::end() noexcept;
-// constexpr const_iterator optional::end() noexcept;
+// constexpr const_iterator optional::end() const noexcept;
 
 #include <cassert>
 #include <iterator>
-#include <ranges>
 #include <optional>
+#include <ranges>
+#include <utility>
 
 template <typename T>
 constexpr bool test() {
   std::optional<T> disengaged{std::nullopt};
-  const std::optional<T> disengaged2{std::nullopt};
 
   { // end() is marked noexcept
     static_assert(noexcept(disengaged.end()));
-    static_assert(noexcept(disengaged2.end()));
+    static_assert(noexcept(std::as_const(disengaged).end()));
   }
 
   { // end() == begin() and end() == end() if the optional is disengaged
     auto it  = disengaged.end();
-    auto it2 = disengaged2.end();
+    auto it2 = std::as_const(disengaged).end();
 
     assert(it == disengaged.begin());
     assert(disengaged.begin() == it);
     assert(it == disengaged.end());
 
-    assert(it2 == disengaged2.begin());
-    assert(disengaged2.begin() == it2);
-    assert(it2 == disengaged2.end());
+    assert(it2 == std::as_const(disengaged).begin());
+    assert(std::as_const(disengaged).begin() == it2);
+    assert(it2 == std::as_const(disengaged).end());
   }
 
   std::optional<T> engaged{T{}};
-  const std::optional<T> engaged2{T{}};
 
   { // end() != begin() if the optional is engaged
     auto it  = engaged.end();
-    auto it2 = engaged2.end();
+    auto it2 = std::as_const(engaged).end();
 
     assert(it != engaged.begin());
     assert(engaged.begin() != it);
 
-    assert(it2 != engaged2.begin());
-    assert(engaged2.begin() != it2);
+    assert(it2 != std::as_const(engaged).begin());
+    assert(std::as_const(engaged).begin() != it2);
   }
 
   return true;

libcxx/test/std/utilities/optional/optional.iterator/iterator.pass.cpp

@@ -21,19 +21,18 @@
 
 template <typename T, T __val>
 constexpr bool test() {
-  const std::optional<T> opt{__val};
-  std::optional<T> nonconst_opt{__val};
+  std::optional<T> opt{__val};
 
   { // Dereferencing an iterator of an engaged optional will return the same value that the optional holds.
     auto it  = opt.begin();
-    auto it2 = nonconst_opt.begin();
+    auto it2 = std::as_const(opt).begin();
     assert(*it == *opt);
-    assert(*it2 == *nonconst_opt);
+    assert(*it2 == *std::as_const(opt));
   }
 
   { // optional::iterator and optional::const_iterator satisfy the Cpp17RandomAccessIterator and contiguous iterator.
     auto it  = opt.begin();
-    auto it2 = nonconst_opt.begin();
+    auto it2 = std::as_const(opt).begin();
     assert(std::contiguous_iterator<decltype(it)>);
     assert(std::contiguous_iterator<decltype(it2)>);
 
@@ -43,18 +42,18 @@ constexpr bool test() {
 
   { // const_iterator::value_type == std::remove_cv_t<T>, const_iterator::reference == const T&, iterator::value_type = std::remove_cv_t<T>, iterator::reference == T&
     auto it  = opt.begin();
-    auto it2 = nonconst_opt.begin();
+    auto it2 = std::as_const(opt).begin();
     assert((std::is_same_v<typename decltype(it)::value_type, std::remove_cv_t<T>>));
-    assert((std::is_same_v<typename decltype(it)::reference, const T&>));
+    assert((std::is_same_v<typename decltype(it)::reference, T&>));
     assert((std::is_same_v<typename decltype(it2)::value_type, std::remove_cv_t<T>>));
-    assert((std::is_same_v<typename decltype(it2)::reference, T&>));
+    assert((std::is_same_v<typename decltype(it2)::reference, const T&>));
   }
 
   { // std::ranges::size for an engaged optional<T> == 1, disengaged optional<T> == 0
     const std::optional<T> disengaged{std::nullopt};
     std::optional<T> disengaged2{std::nullopt};
     assert(std::ranges::size(opt) == 1);
-    assert(std::ranges::size(nonconst_opt) == 1);
+    assert(std::ranges::size(std::as_const(opt)) == 1);
 
     assert(std::ranges::size(disengaged) == 0);
     assert(std::ranges::size(disengaged2) == 0);