[libc++][test] zip_view test cleanups

[CaseyCarter]

Summary

• The reference type of common_input_iterator<const int*> can't be int&, because an lvalue of type const int _can't_ bind to an int&. Fix by changing the return type of operator* to decltype(auto) to make it fully generic.
• range.zip/iterator/compare.pass.cpp verifies that the iterators of a zip_view don't support <=> when the underlying iterators do not; this is not true after LWG-3692.
• libc++ doesn't yet implement P2165R4 "Compatibility between tuple, pair and tuple-like objects", so the tests expect zip_view to use pair in places where the working draft requires tuple.

[CaseyCarter]

Add another fix.

[CaseyCarter]

Deal with differences due to P2165R4.

[philnik]

libcxx/test/std/ranges/range.adaptors/range.zip/cpo.pass.cpp

66

Maybe guard this on defined(__cpp_lib_tuple_like) && __cpp_lib_tuple_like >= 202207L?

libcxx/test/std/ranges/range.adaptors/range.zip/types.h

305–325

Maybe we should lift this into test_iterators.h. This seems like the kind of thing that gets duplicated very easily.

[huixie90]

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.default.pass.cpp

53–60

In theory I guess we should check the feature test macro __cpp_lib_tuple_like, but I think I prefer your solution. We are going to implement the paper without supporting the previous behaviour. so after implementing the paper, a test failure would be preferable over silently selecting another branch.

libcxx/test/std/ranges/range.adaptors/range.zip/types.h

322

Thanks for the fix. I think this function is not used in the tests. The main usage of this class is to test the end function returns the correct type and compares with the iterator correctly (without calling operator*)
btw, I prefer decltype(auto) here even though it does not really matter.

[CaseyCarter]

libcxx/test/std/ranges/range.adaptors/range.zip/cpo.pass.cpp

66

As Hui commented below, the intent isn't to keep both alternatives. My intent is that these tests break loudly upon implementing P2165R4 so someone will open them up and remove the "old" code instead of leaving it dead. We could equivalently have _only_ the P2165R4 behavior and XFAIL these tests for libc++ but I prefer to validate the "wrong" behavior for the time being to defend against regressions that would cause the test to fail but in a different way.

Full disclosure: MSVCSTL has been implementing P2165 piecemeal, so we don't define the feature-test macro yet. Guarding with the macro wouldn't accomplish my goal of getting all of these tests up on MSVC.

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.default.pass.cpp

53–60

I argue for this approach in some detail in my response to Philnik's comment above.

libcxx/test/std/ranges/range.adaptors/range.zip/types.h

322

I used auto& to conservatively make this "just generic enough to cover existing uses" but I agree that full decltype(auto) is more completely future-proof.

[CaseyCarter]

Change return type of common_input_iterator::operator* to decltype(auto).

[CaseyCarter]

libcxx/test/std/ranges/range.adaptors/range.zip/types.h

305–325

I'd prefer to land this as-is and leave any such code motion to a followup PR.

[philnik]

libcxx/test/std/ranges/range.adaptors/range.zip/cpo.pass.cpp

66

Makes sense.

libcxx/test/std/ranges/range.adaptors/range.zip/types.h

305–325

That's all right. @jloser already uploaded D141238.

libcxx/test/std/ranges/range.adaptors/range.zip/cpo.pass.cpp

constexpr bool test() {
     int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
     std::same_as<std::ranges::zip_view<SizedRandomAccessView, SizedRandomAccessView>> decltype(auto) v =
         std::views::zip(SizedRandomAccessView{buffer}, SizedRandomAccessView{buffer});
 
     std::same_as<
         std::ranges::zip_view<std::ranges::zip_view<SizedRandomAccessView, SizedRandomAccessView>>> decltype(auto) v2 =
         std::views::zip(v);
 
+#ifdef _LIBCPP_VERSION // libc++ doesn't implement P2165R4 yet
     static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(v2)>, std::tuple<std::pair<int&, int&>>>);
+#else
+    static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(v2)>, std::tuple<std::tuple<int&, int&>>>);
+#endif
   }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.default.pass.cpp

 static_assert(!std::is_default_constructible_v<std::ranges::zip_view<NoDefaultCtrView>>);
 
 constexpr bool test() {
   {
     using View = std::ranges::zip_view<DefaultConstructibleView, DefaultConstructibleView>;
     View v = View(); // the default constructor is not explicit
     assert(v.size() == 3);
     auto it = v.begin();
-    using Pair = std::pair<const int&, const int&>;
-    assert(*it++ == Pair(buff[0], buff[0]));
-    assert(*it++ == Pair(buff[1], buff[1]));
-    assert(*it == Pair(buff[2], buff[2]));
+#ifdef _LIBCPP_VERSION // libc++ doesn't implement P2165R4 yet
+    using Value = std::pair<const int&, const int&>;
+#else
+    using Value = std::tuple<const int&, const int&>;
+#endif
+    assert(*it++ == Value(buff[0], buff[0]));
+    assert(*it++ == Value(buff[1], buff[1]));
+    assert(*it == Value(buff[2], buff[2]));
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp

constexpr bool test() {
 
   {
     // Test an old-school iterator with no operator<=>; the transform iterator shouldn't have
     // operator<=> either.
     using It = random_access_iterator<int*>;
     using Subrange = std::ranges::subrange<It>;
     static_assert(!std::three_way_comparable<It>);
     using R = std::ranges::zip_view<Subrange, Subrange>;
+#ifdef _LIBCPP_VERSION
+    // libc++ hasn't implemented LWG-3692 "zip_view::iterator's operator<=> is overconstrained"
     static_assert(!std::three_way_comparable<std::ranges::iterator_t<R>>);
+#else
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
+#endif
 
     int a[] = {1, 2, 3, 4};
     int b[] = {5, 6, 7, 8, 9};
     auto r = std::views::zip(Subrange(It(a), It(a + 4)), Subrange(It(b), It(b + 5)));
     auto iter1 = r.begin();
     auto iter2 = iter1 + 1;
 
     compareOperatorTest(iter1, iter2);

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/deref.pass.cpp

constexpr bool test() {
 
   {
     // two ranges with different types
     std::ranges::zip_view v(a, b);
     auto it = v.begin();
     auto [x, y] = *it;
     assert(&x == &(a[0]));
     assert(&y == &(b[0]));
+#ifdef _LIBCPP_VERSION // libc++ doesn't implement P2165R4 yet
     static_assert(std::is_same_v<decltype(*it), std::pair<int&, double&>>);
+#else
+    static_assert(std::is_same_v<decltype(*it), std::tuple<int&, double&>>);
+#endif
 
     x = 5;
     y = 0.1;
     assert(a[0] == 5);
     assert(b[0] == 0.1);
   }
 
   {
     // underlying range with prvalue range_reference_t
     std::ranges::zip_view v(a, b, std::views::iota(0, 5));
     auto it = v.begin();
     assert(&(std::get<0>(*it)) == &(a[0]));
     assert(&(std::get<1>(*it)) == &(b[0]));
     assert(std::get<2>(*it) == 0);
     static_assert(std::is_same_v<decltype(*it), std::tuple<int&, double&, int>>);
   }
 
   {
     // const-correctness
     std::ranges::zip_view v(a, std::as_const(a));
     auto it = v.begin();
     assert(&(std::get<0>(*it)) == &(a[0]));
     assert(&(std::get<1>(*it)) == &(a[0]));
+#ifdef _LIBCPP_VERSION // libc++ doesn't implement P2165R4 yet
     static_assert(std::is_same_v<decltype(*it), std::pair<int&, int const&>>);
+#else
+    static_assert(std::is_same_v<decltype(*it), std::tuple<int&, int const&>>);
+#endif
   }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/member_types.compile.pass.cpp

int buffer[] = {1, 2, 3, 4};
     // 2 views should have pair value_type
     // random_access_iterator_tag
     std::ranges::zip_view v(buffer, buffer);
     using Iter = decltype(v.begin());
 
     static_assert(std::is_same_v<Iter::iterator_concept, std::random_access_iterator_tag>);
     static_assert(std::is_same_v<Iter::iterator_category, std::input_iterator_tag>);
     static_assert(std::is_same_v<Iter::difference_type, std::ptrdiff_t>);
+#ifdef _LIBCPP_VERSION // libc++ doesn't implement P2165R4 yet
     static_assert(std::is_same_v<Iter::value_type, std::pair<int, int>>);
+#else
+    static_assert(std::is_same_v<Iter::value_type, std::tuple<int, int>>);
+#endif
     static_assert(HasIterCategory<Iter>);
   }
 
   {
     // !=2 views should have tuple value_type
     std::ranges::zip_view v(buffer, buffer, buffer);
     using Iter = decltype(v.begin());
 
#endif
     // nested zip_view
     std::ranges::zip_view v(buffer, buffer);
     std::ranges::zip_view v2(buffer, v);
     using Iter = decltype(v2.begin());
 
     static_assert(std::is_same_v<Iter::iterator_concept, std::random_access_iterator_tag>);
     static_assert(std::is_same_v<Iter::iterator_category, std::input_iterator_tag>);
     static_assert(std::is_same_v<Iter::difference_type, std::ptrdiff_t>);
+#ifdef _LIBCPP_VERSION // libc++ doesn't implement P2165R4 yet
     static_assert(std::is_same_v<Iter::value_type, std::pair<int, std::pair<int, int>>>);
+#else
+    static_assert(std::is_same_v<Iter::value_type, std::tuple<int, std::tuple<int, int>>>);
+#endif
     static_assert(HasIterCategory<Iter>);
   }
 
   {
     // input_iterator_tag
     using Iter = std::ranges::iterator_t<std::ranges::zip_view<InputView<int>>>;
 
     static_assert(std::is_same_v<Iter::iterator_concept, std::input_iterator_tag>);
std::array bars{Bar{}, Bar{}};
     using Iter = decltype(v.begin());
     static_assert(std::is_same_v<Iter::value_type, std::tuple<Foo>>);
   }
 
   {
     // value_type of multiple views with different value_type
     std::ranges::zip_view v{foos, bars};
     using Iter = decltype(v.begin());
+#ifdef _LIBCPP_VERSION // libc++ doesn't implement P2165R4 yet
     static_assert(std::is_same_v<Iter::value_type, std::pair<Foo, Bar>>);
+#else
+    static_assert(std::is_same_v<Iter::value_type, std::tuple<Foo, Bar>>);
+#endif
   }
 
   {
     // const-iterator different from iterator
     std::ranges::zip_view v{ConstVeryDifferentRange{}};
     using Iter = decltype(v.begin());
     using ConstIter = decltype(std::as_const(v).begin());
 

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/subscript.pass.cpp

constexpr bool test() {
   {
     // random_access_range
     std::ranges::zip_view v(SizedRandomAccessView{buffer}, std::views::iota(0));
     auto it = v.begin();
     assert(it[0] == *it);
     assert(it[2] == *(it + 2));
     assert(it[4] == *(it + 4));
 
+#ifdef _LIBCPP_VERSION // libc++ doesn't implement P2165R4 yet
     static_assert(std::is_same_v<decltype(it[2]), std::pair<int&, int>>);
+#else
+    static_assert(std::is_same_v<decltype(it[2]), std::tuple<int&, int>>);
+#endif
   }
 
   {
     // contiguous_range
     std::ranges::zip_view v(ContiguousCommonView{buffer}, ContiguousCommonView{buffer});
     auto it = v.begin();
     assert(it[0] == *it);
     assert(it[2] == *(it + 2));
     assert(it[4] == *(it + 4));
 
+#ifdef _LIBCPP_VERSION // libc++ doesn't implement P2165R4 yet
     static_assert(std::is_same_v<decltype(it[2]), std::pair<int&, int&>>);
+#else
+    static_assert(std::is_same_v<decltype(it[2]), std::tuple<int&, int&>>);
+#endif
   }
 
   {
     // non random_access_range
     std::ranges::zip_view v(BidiCommonView{buffer});
     auto iter = v.begin();
     const auto canSubscript = [](auto&& it) { return requires { it[0]; }; };
     static_assert(!canSubscript(iter));

libcxx/test/std/ranges/range.adaptors/range.zip/types.h

 static_assert(!std::ranges::sized_range<ContiguousNonCommonView>);
 
 using ContiguousNonCommonSized = BasicView<int*, sized_sentinel<int*>>;
 
 static_assert(std::ranges::contiguous_range<ContiguousNonCommonSized>);
 static_assert(!std::ranges::common_range<ContiguousNonCommonSized>);
 static_assert(std::ranges::sized_range<ContiguousNonCommonSized>);
 
 template <class Base = int*>
 struct common_input_iterator {
   Base it_;
 
   using value_type = int;
   using difference_type = std::intptr_t;
   using iterator_concept = std::input_iterator_tag;
 
   constexpr common_input_iterator() = default;
   constexpr explicit common_input_iterator(Base it) : it_(it) {}
 
   constexpr common_input_iterator& operator++() {
     ++it_;
     return *this;
   }
   constexpr void operator++(int) { ++it_; }
 
-  constexpr int& operator*() const { return *it_; }
+  constexpr decltype(auto) operator*() const { return *it_; }
 
   friend constexpr bool operator==(common_input_iterator const&, common_input_iterator const&) = default;
 };
 
 using InputCommonView = BasicView<common_input_iterator<>>;
 static_assert(std::ranges::input_range<InputCommonView>);
 static_assert(!std::ranges::forward_range<InputCommonView>);
 static_assert(std::ranges::common_range<InputCommonView>);
 LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<InputCommonView>);
 
 using NonSimpleInputCommonView = BasicView<common_input_iterator<const int*>, common_input_iterator<const int*>,