Split test file into three tests

Author: smallp-o-p

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

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++26
+
+// <optional>
+
+// constexpr iterator optional::begin() noexcept;
+// constexpr const_iterator optional::begin() noexcept;
+
+#include <cassert>
+#include <iterator>
+#include <optional>
+#include <type_traits>
+
+template <typename T>
+constexpr bool test() {
+  constexpr std::optional<T> opt{T{}};
+  std::optional<T> nonconst_opt{T{}};
+
+  { // begin() is marked noexcept
+    assert(noexcept(opt.begin()));
+    assert(noexcept(nonconst_opt.begin()));
+  }
+
+  { // Dereferencing an iterator at the beggining as indexing the 0th element, and that those iterators are the same value returned by calling begin() again.
+    auto iter1 = opt.begin();
+    auto iter2 = nonconst_opt.begin();
+    assert(*iter1 == iter1[0]);
+    assert(*iter2 == iter2[0]);
+    assert(iter1 == opt.begin());
+    assert(iter2 == nonconst_opt.begin());
+  }
+
+  return true;
+}
+
+constexpr bool tests() {
+  assert(test<int>());
+  assert(test<char>());
+  assert(test<const int>());
+  assert(test<const char>());
+  return true;
+}
+
+int main() {
+  assert(tests());
+  static_assert(tests());
+
+  return 0;
+}

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

@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++26
+
+// <optional>
+
+// constexpr iterator optional::end() noexcept;
+// constexpr const_iterator optional::end() noexcept;
+
+#include <cassert>
+#include <iterator>
+#include <ranges>
+#include <optional>
+
+template <typename T>
+constexpr bool test() {
+  std::optional<T> unengaged{std::nullopt};
+  constexpr std::optional<T> unengaged2{std::nullopt};
+
+  { // end() == begin() and end() == end() if the optional is unengaged
+    auto it  = unengaged.end();
+    auto it2 = unengaged2.end();
+
+    assert(it == unengaged.begin());
+    assert(unengaged.begin() == it);
+    assert(it == unengaged.end());
+
+    assert(it2 == unengaged2.begin());
+    assert(unengaged2.begin() == it2);
+    assert(it2 == unengaged2.end());
+  }
+
+  std::optional<T> engaged{T{}};
+  constexpr std::optional<T> engaged2{T{}};
+
+  { // end() != begin() if the optional is engaged
+    auto it  = engaged.end();
+    auto it2 = engaged2.end();
+
+    assert(it != engaged.begin());
+    assert(engaged.begin() != it);
+
+    assert(it2 != engaged2.begin());
+    assert(engaged2.begin() != it2);
+  }
+
+  return true;
+}
+
+constexpr bool tests() {
+  assert(test<int>());
+  assert(test<char>());
+  assert(test<const int>());
+  assert(test<const char>());
+
+  return true;
+}
+
+int main() {
+  assert(tests());
+  static_assert(tests());
+}

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

@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++26
+
+// <optional>
+
+// template <class T> class optional::iterator;
+// template <class T> class optional::const_iterator;
+
+#include <cassert>
+#include <iterator>
+#include <optional>
+#include <ranges>
+#include <type_traits>
+
+template <typename T, T __val>
+constexpr bool test() {
+  constexpr std::optional<T> opt{__val};
+  std::optional<T> nonconst_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();
+    assert(*it == *opt);
+    assert(*it2 == *nonconst_opt);
+  }
+
+  { // optional::iterator and optional::const_iterator satisfy the Cpp17RandomAccessIterator and contiguous iterator.
+    auto it  = opt.begin();
+    auto it2 = nonconst_opt.begin();
+    assert(std::contiguous_iterator<decltype(it)>);
+    assert(std::contiguous_iterator<decltype(it2)>);
+
+    assert(std::random_access_iterator<decltype(it)>);
+    assert(std::random_access_iterator<decltype(it2)>);
+  }
+
+  { // 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();
+    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(it2)::value_type, std::remove_cv_t<T>>));
+    assert((std::is_same_v<typename decltype(it2)::reference, T&>));
+  }
+
+  { // std::ranges for an engaged optional<T> == 1, unengaged optional<T> == 0
+    constexpr std::optional<T> unengaged{std::nullopt};
+    std::optional<T> unengaged2{std::nullopt};
+    assert(std::ranges::size(opt) == 1);
+    assert(std::ranges::size(nonconst_opt) == 1);
+
+    assert(std::ranges::size(unengaged) == 0);
+    assert(std::ranges::size(unengaged2) == 0);
+  }
+
+  { // std::ranges::enable_view<optional<T>> == true, and std::format_kind<optional<T>> == true
+    assert(std::ranges::enable_view<std::optional<T>> == true);
+    assert(std::format_kind<std::optional<T>> == std::range_format::disabled);
+  }
+
+  // 8: An optional with value that is reset will have a begin() == end(), then when it is reassigned a value, begin() != end(), and *begin() will contain the new value.
+  {
+    std::optional<T> val{__val};
+    assert(val.begin() != val.end());
+    val.reset();
+    assert(val.begin() == val.end());
+    val.emplace(__val);
+    assert(val.begin() != val.end());
+    assert(*(val.begin()) == __val);
+  }
+
+  return true;
+}
+
+constexpr bool tests() {
+  assert((test<int, 1>()));
+  assert((test<char, 'a'>()));
+  assert((test<bool, true>()));
+  assert((test<const int, 2>()));
+  assert((test<const char, 'b'>()));
+
+  return true;
+}
+
+int main() {
+  assert(tests());
+  static_assert(tests());
+}