add more valueless iterator test

Author: changkhothuychung

libcxx/include/__ranges/concat_view.h

@@ -577,7 +577,7 @@ class concat_view<_Views...>::__iterator : public __concat_view_iterator_categor
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
         !__x.__it_.valueless_by_exception(),
         "Trying to subtract a valuess iterators of concat_view from the default sentinel.");
-    __x.__invoke_at_index([&]<std::size_t __index_x>() -> difference_type {
+    return __x.__invoke_at_index([&]<std::size_t __index_x>() -> difference_type {
       auto __dx           = ranges::distance(ranges::begin(std::get<__index_x>(__x.__parent_->__views_)), __x.__it_);
       difference_type __s = [&]<std::size_t __start, std::size_t __end>(this auto&& self) -> difference_type {
         if constexpr (__start < __end) {

libcxx/test/libcxx/ranges/range.adaptors/range.concat/iterator.valueless_by_exception.pass.cpp

@@ -101,11 +101,12 @@ struct Iter {
   template <std::size_t X, std::size_t Y>
   friend difference_type operator-(Iter<X> a, Iter<Y> b);
 
-  friend bool operator==(Iter a, Iter b) = default;
+  friend bool operator==(Iter a, Iter b) { return a.ptr_ == b.ptr_; };
   friend bool operator<(Iter a, Iter b) { return a.ptr_ < b.ptr_; }
   friend bool operator>(Iter a, Iter b) { return a.ptr_ > b.ptr_; }
   friend bool operator<=(Iter a, Iter b) { return a.ptr_ <= b.ptr_; }
   friend bool operator>=(Iter a, Iter b) { return a.ptr_ >= b.ptr_; }
+  friend auto operator<=>(Iter a, Iter b) { return a.ptr_ <=> b.ptr_; }
 };
 
 template <std::size_t X>
@@ -132,6 +133,7 @@ template <std::size_t N>
 struct Range : std::ranges::view_base {
   using iterator       = Iter<N>;
   using const_iterator = Iter<N>;
+  using sentinel       = sentinel_wrapper<iterator>;
 
   int* data_;
   std::size_t size_;
@@ -189,6 +191,22 @@ int main() {
     }
   }
 
+  {
+    // valueless by exception test operator== with a sentinel
+    flag = false;
+    Range<0> r1;
+    Range<1> r2;
+    auto cv    = std::views::concat(r1, r2);
+    auto iter1 = cv.begin();
+    auto iter2 = std::ranges::next(cv.begin(), 4);
+    flag       = true;
+    try {
+      iter1 = std::move(iter2);
+    } catch (...) {
+      TEST_LIBCPP_ASSERT_FAILURE([=] { (void)(iter1 == std::default_sentinel); }(), "valueless by exception");
+    }
+  }
+
   {
     // valueless by exception test operator--
     flag = false;
@@ -202,7 +220,7 @@ int main() {
     try {
       iter1 = std::move(iter2);
     } catch (...) {
-      TEST_LIBCPP_ASSERT_FAILURE([&] { iter1--; }(), "valueless by exception");
+      TEST_LIBCPP_ASSERT_FAILURE([&] { --iter1; }(), "valueless by exception");
     }
   }
 
@@ -240,6 +258,108 @@ int main() {
     }
   }
 
+  {
+    // valueless by exception test operator>
+    flag = false;
+    Range<0> r1;
+    Range<1> r2;
+
+    auto cv    = std::views::concat(r1, r2);
+    auto iter1 = cv.begin();
+    auto iter2 = std::ranges::next(cv.begin(), 4);
+    flag       = true;
+    try {
+      iter1 = std::move(iter2);
+    } catch (...) {
+      TEST_LIBCPP_ASSERT_FAILURE([&] { (void)(iter1 > iter2); }(), "valueless by exception");
+    }
+  }
+
+  {
+    // valueless by exception test operator>=
+    flag = false;
+    Range<0> r1;
+    Range<1> r2;
+
+    auto cv    = std::views::concat(r1, r2);
+    auto iter1 = cv.begin();
+    auto iter2 = std::ranges::next(cv.begin(), 4);
+    flag       = true;
+    try {
+      iter1 = std::move(iter2);
+    } catch (...) {
+      TEST_LIBCPP_ASSERT_FAILURE([&] { (void)(iter1 >= iter2); }(), "valueless by exception");
+    }
+  }
+
+  {
+    // valueless by exception test operator<
+    flag = false;
+    Range<0> r1;
+    Range<1> r2;
+
+    auto cv    = std::views::concat(r1, r2);
+    auto iter1 = cv.begin();
+    auto iter2 = std::ranges::next(cv.begin(), 4);
+    flag       = true;
+    try {
+      iter1 = std::move(iter2);
+    } catch (...) {
+      TEST_LIBCPP_ASSERT_FAILURE([&] { (void)(iter1 < iter2); }(), "valueless by exception");
+    }
+  }
+
+  {
+    // valueless by exception test operator<=
+    flag = false;
+    Range<0> r1;
+    Range<1> r2;
+
+    auto cv    = std::views::concat(r1, r2);
+    auto iter1 = cv.begin();
+    auto iter2 = std::ranges::next(cv.begin(), 4);
+    flag       = true;
+    try {
+      iter1 = std::move(iter2);
+    } catch (...) {
+      TEST_LIBCPP_ASSERT_FAILURE([&] { (void)(iter1 <= iter2); }(), "valueless by exception");
+    }
+  }
+
+  {
+    // valueless by exception test operator- between two iterators
+    flag = false;
+    Range<0> r1;
+    Range<1> r2;
+
+    auto cv    = std::views::concat(r1, r2);
+    auto iter1 = cv.begin();
+    auto iter2 = std::ranges::next(cv.begin(), 4);
+    flag       = true;
+    try {
+      iter1 = std::move(iter2);
+    } catch (...) {
+      TEST_LIBCPP_ASSERT_FAILURE([&] { (void)(iter1 - iter2); }(), "valueless by exception");
+    }
+  }
+
+  {
+    // valueless by exception test operator- with a constant
+    flag = false;
+    Range<0> r1;
+    Range<1> r2;
+
+    auto cv    = std::views::concat(r1, r2);
+    auto iter1 = cv.begin();
+    auto iter2 = std::ranges::next(cv.begin(), 4);
+    flag       = true;
+    try {
+      iter1 = std::move(iter2);
+    } catch (...) {
+      TEST_LIBCPP_ASSERT_FAILURE([&] { (void)(iter1 - 1); }(), "valueless by exception");
+    }
+  }
+
   {
     // valueless by exception test constructor
     flag = false;