fix test

Author: changkhothuychung

libcxx/include/__ranges/concat_view.h

@@ -491,8 +491,8 @@ class concat_view<_Views...>::__iterator : public __concat_view_iterator_categor
   }
 
   _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
-    requires((random_access_range<__maybe_const<_Const, _Views>> && ...) &&
-             (three_way_comparable<__maybe_const<_Const, _Views>> && ...))
+    requires((__all_random_access<_Const, _Views> && ...) &&
+             (three_way_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...))
   {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__x.__it_.valueless_by_exception() && !__y.__it_.valueless_by_exception(),
                                         "Trying to compare a valueless iterator of concat_view.");

libcxx/test/std/ranges/range.adaptors/range.concat/constraints.pass.cpp

@@ -11,18 +11,46 @@
 #include <cassert>
 #include <list>
 #include <ranges>
+#include <type_traits>
 #include <vector>
 #include "test_iterators.h"
 #include "test_macros.h"
 
-// This tests https://cplusplus.github.io/LWG/issue4082
-// views::concat(r) is well-formed when r is an output_range
+// test concept constraints
 
 template<typename T>
 concept WellFormedView = requires(T& a) {
   std::views::concat(a);
 };
 
+struct X {};
+
+struct BadIter {
+  using value_type = int;
+  int* p;
+
+  BadIter() = default;
+  explicit BadIter(int* q) : p(q) {}
+
+  int& operator*() const { return *p; }
+  BadIter& operator++() {
+    ++p;
+    return *this;
+  }
+  void operator++(int) { ++p; }
+
+  friend bool operator==(const BadIter& a, const BadIter& b) { return a.p == b.p; }
+  friend bool operator!=(const BadIter& a, const BadIter& b) { return !(a == b); }
+
+  friend X iter_move(const BadIter&) { return X{}; }
+};
+
+struct BadView : std::ranges::view_base {
+  int buf_[1] = {0};
+  BadIter begin() const { return BadIter(const_cast<int*>(buf_)); }
+  BadIter end() const { return BadIter(const_cast<int*>(buf_ + 1)); }
+};
+
 struct InputRange {
   using Iterator = cpp17_input_iterator<int*>;
   using Sentinel = sentinel_wrapper<Iterator>;
@@ -84,5 +112,20 @@ int main(int, char**) {
     static_assert(!ConcatViewConstraintsPass<std::vector<int>, std::vector<std::string>>);
   }
 
+  {
+    // test concept concatable
+    {
+      // concat-reference-t is ill-formed
+      // no common reference between int and string
+      static_assert(!ConcatViewConstraintsPass<std::array<int, 1>, std::array<std::string, 1>>);
+    }
+
+    {
+      // concat-indirectly-readable is ill-formed
+      //   since iter_move of BadIter returns an unrelated type
+      static_assert(!ConcatViewConstraintsPass<BadView, BadView>);
+    }
+  }
+
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/arithmetic.pass.cpp

@@ -8,21 +8,20 @@
 
 // REQUIRES: std-at-least-c++26
 
-// friend constexpr iterator operator-(const iterator& it, difference_type n)
-//         requires concat-is-random-access<Const, Views...>;
-
-// friend constexpr difference_type operator-(const iterator& x, const iterator& y)
-//     requires concat-is-random-access<Const, Views...>;
-
-// friend constexpr difference_type operator-(default_sentinel_t, const __iterator& __x)
-//     requires(sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&
-//              ...) &&
-//             (__all_but_first_model_sized_range<_Const, _Views...>::value)
-
-// friend constexpr difference_type operator-(const __iterator& __x, default_sentinel_t)
-//     requires(sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&
-//              ...) &&
-//             (__all_but_first_model_sized_range<_Const, _Views...>::value)
+// operator-(x, y)
+// operator-(x, sentinel)
+// operator-(sentinel, x)
+// operator-(x, n)
+// operator+(x, n)
+// operator+=(x, n)
+// operator-=(x, n)
+// operator<(x, y)
+// operator<=(x, y)
+// operator>=(x, y)
+// operator>(x, y)
+// operator<=>(x, y)
+// operator==(x, y)
+// operator==(x, sentinel)
 
 #include <array>
 #include <concepts>
@@ -182,6 +181,125 @@ constexpr bool test() {
     }
   }
 
+  {
+    // operator <, <=, >, >=
+    std::array<int, 4> arr_a{1, 2, 3, 4};
+    std::array<int, 3> arr_b{5, 6, 7};
+    std::span<const int> s1{arr_a};
+    std::span<const int> s2{arr_b};
+    auto v      = std::views::concat(s1, s2);
+    using Iter  = decltype(v.begin());
+    using CIter = decltype(std::as_const(v).begin());
+    auto i      = v.begin();
+    auto j      = v.begin();
+    std::ranges::advance(j, arr_a.size());
+
+    assert(i < j);
+    assert(i <= j);
+    assert(!(i > j));
+    assert(!(i >= j));
+    auto ord1 = (i <=> j);
+    assert(ord1 < 0);
+    assert((j <=> i) > 0);
+
+    auto k = j;
+    assert(!(j < k));
+    assert(j <= k);
+    assert(!(j > k));
+    assert(j >= k);
+    auto ord2 = (j <=> k);
+    assert(ord2 == 0);
+
+    // const-iterator
+    const auto& cv = v;
+    auto ci        = cv.begin();
+    auto cj        = cv.begin();
+    std::ranges::advance(cj, arr_a.size());
+    assert(ci < cj);
+    assert((ci <=> cj) < 0);
+  }
+
+  {
+    // operator==(x, sentinel)
+    std::array<int, 2> arr_a{1, 2};
+    std::array<int, 2> arr_b{3, 4};
+    std::span<const int> s1{arr_a};
+    std::span<const int> s2{arr_b};
+    auto v = std::views::concat(s1, s2);
+
+    auto it = v.begin();
+    assert(!(it == std::default_sentinel_t{}));
+
+    it++;
+    it++;
+    it++;
+    it++;
+    assert(it == std::default_sentinel_t{});
+
+    // const-iterator
+    const auto& cv = v;
+    auto cit       = cv.begin();
+    ++cit;
+    ++cit;
+    ++cit;
+    ++cit;
+    assert(cit == std::default_sentinel_t{});
+  }
+
+  {
+    // operator+(x, n) and operator+(n, x), where n is negative
+    std::array<int, 4> arr_a{1, 2, 3, 4};
+    std::array<int, 3> arr_b{5, 6, 7};
+    std::span<const int> s1{arr_a};
+    std::span<const int> s2{arr_b};
+    auto v = std::views::concat(s1, s2);
+
+    auto i = v.begin();
+    std::ranges::advance(i, arr_a.size());
+
+    auto j   = i;
+    auto j_1 = j + (-1);
+    assert(*j_1 == arr_a.back());
+    auto j_3 = j + (-3);
+    assert(*j_3 == arr_a[1]);
+
+    // n + x (negative)
+    auto k = (-1) + j;
+    assert(*k == arr_a.back());
+
+    // const-iterator
+    auto ci = std::as_const(v).begin();
+    std::ranges::advance(ci, arr_a.size());
+    auto cj   = ci;
+    auto cj_2 = cj + (-2);
+    assert(*cj_2 == arr_a[2]);
+    auto cjn = (-1) + cj;
+    assert(*cjn == arr_a.back());
+  }
+
+  {
+    // operator-(x, n), where n is negative
+    std::array<int, 4> arr_a{1, 2, 3, 4};
+    std::array<int, 3> arr_b{5, 6, 7};
+    std::span<const int> s1{arr_a};
+    std::span<const int> s2{arr_b};
+    auto v = std::views::concat(s1, s2);
+
+    auto i = v.begin();
+
+    auto j   = i;
+    auto j_1 = j - (-1);
+    assert(*j_1 == arr_a[1]);
+    auto j_3 = j - (-3);
+    assert(*j_3 == arr_a.back());
+
+    // const-iterator
+    auto ci   = std::as_const(v).begin();
+    auto cj   = ci;
+    auto cj_2 = cj - (-2);
+    assert(*cj_2 == arr_a[2]);
+  }
+
   return true;
 }
 

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/decrement.pass.cpp

@@ -126,13 +126,11 @@ constexpr bool test() {
   {
     auto v = std::views::concat(a, b);
 
-    // Position at the first element of `b`, then -- to land on a.back().
     auto it = v.begin();
     it += a.size();
     --it;
     assert(*it == a.back());
 
-    // Post-decrement variant from b[0]; result is old iterator, `it2` moves to a.back().
     auto it2 = v.begin();
     it2 += a.size();
     auto old = it2--;
@@ -165,7 +163,7 @@ constexpr bool test() {
     auto v = std::views::concat(a, e, b);
 
     auto it = v.begin();
-    it += a.size(); // points at beginning of b
+    it += a.size();
     --it;           // this skips e
     assert(*it == a.back());
 
@@ -189,7 +187,7 @@ constexpr bool test() {
     auto v = std::views::concat(a, e1, e2, b);
 
     auto it = v.begin();
-    it += a.size(); // points to b[0]
+    it += a.size();
     --it;           // skip e2 and e1
     assert(*it == a.back());
   }

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/increment.pass.cpp

@@ -8,11 +8,9 @@
 
 // REQUIRES: std-at-least-c++26
 
-// friend constexpr __iterator operator+(const __iterator& __it, difference_type __n)
-//     requires __concat_is_random_access<_Const, _Views...>
+// constexpr __iterator& operator++()
 
-// friend constexpr __iterator operator+(difference_type __n, const __iterator& __it)
-//     requires __concat_is_random_access<_Const, _Views...>
+// constexpr void operator++(int)
 
 #include <array>
 #include <cassert>
@@ -100,6 +98,81 @@ constexpr bool test() {
     assert(*it == a[3]);
   }
 
+  // Different underlying range types; ++ crosses from end of first into start of second.
+  {
+    std::span<const int> sa{a};
+    auto sb = std::ranges::subrange{b.data(), b.data() + b.size()};
+    auto v  = std::views::concat(sa, sb);
+
+    auto it = v.begin();
+    for (size_t i = 1; i < a.size(); i++) {
+      ++it;
+    }
+    assert(*it == a.back());
+
+    ++it;
+    assert(*it == b.front());
+
+    auto it2 = v.begin();
+    for (size_t i = 1; i < a.size(); i++) {
+      ++it2;
+    }
+    auto old = it2++;
+    assert(*old == a.back());
+    assert(*it2 == b.front());
+
+    // Same with a const-iterator.
+    const auto& cv = v;
+    auto cit       = cv.begin();
+    for (size_t i = 1; i < a.size(); i++) {
+      ++cit;
+    }
+    ++cit;
+    assert(*cit == b.front());
+  }
+
+  // ++ crosses into next range when that next range is empty.
+  {
+    std::array<int, 0> e{};
+    auto v = std::views::concat(a, e, b);
+
+    auto it = v.begin();
+    for (size_t i = 1; i < a.size(); i++) {
+      ++it;
+    }
+    ++it; //  skip e
+    assert(*it == b.front());
+
+    auto it2 = v.begin();
+    for (size_t i = 1; i < a.size(); i++)
+      ++it2;
+    auto old = it2++;
+    assert(*old == a.back());
+    assert(*it2 == b.front());
+
+    // Const-iterator.
+    const auto& cv = v;
+    auto cit       = cv.begin();
+    for (size_t i = 1; i < a.size(); i++)
+      ++cit;
+    ++cit;
+    assert(*cit == b.front());
+  }
+
+  // Multiple consecutive empty ranges are skipped on ++.
+  {
+    std::array<int, 0> e1{}, e2{};
+    auto v = std::views::concat(a, e1, e2, b);
+
+    auto it = v.begin();
+    for (size_t i = 1; i < a.size(); i++) {
+      ++it;
+    }
+
+    ++it; // skip e1 and e2
+    assert(*it == b.front());
+  }
+
   return true;
 }