[libc++] [test] Simplify some ranges tests.

[• Quuxplusone]

Summary

Eliminate a bogus operator== overload.
Also, check more intermediate steps in the logic we're checking here.
Some of this simplification is possible only now that we've implemented
more of <ranges>.

[ldionne]

libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp

72–73

I don't understand how this change is related to the bogus operator== removal?

[• Quuxplusone]

libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp

72–73

It's not (other than mentioning a "SizedForwardView", which is probably why it was on my radar at the same time). It's related to "Simplify some ranges tests," though.

libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp

int main(int, char**) {
   int buf[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     SizedForwardView view{buf, buf + 8};
     std::ranges::common_view<SizedForwardView> common(view);
     using CommonIter = std::common_iterator<ForwardIter, sized_sentinel<ForwardIter>>;
     std::same_as<CommonIter> auto begin = common.begin();
     assert(begin == std::ranges::begin(view));
-  }
-  {
-    SizedForwardView view{buf, buf + 8};
-    std::ranges::common_view<SizedForwardView> const common(view);
-    using CommonIter = std::common_iterator<ForwardIter, sized_sentinel<ForwardIter>>;
-    std::same_as<CommonIter> auto begin = common.begin();
-    assert(begin == std::ranges::begin(view));
+    std::same_as<CommonIter> auto cbegin = std::as_const(common).begin();
+    assert(cbegin == std::ranges::begin(view));
   }
 
   {
     MoveOnlyView view{buf, buf + 8};
     std::ranges::common_view<MoveOnlyView> common(std::move(view));
     using CommonIter = std::common_iterator<int*, sentinel_wrapper<int*>>;
     std::same_as<CommonIter> auto begin = common.begin();
     assert(begin == std::ranges::begin(view));

libcxx/test/std/ranges/range.adaptors/range.take/sentinel/base.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../types.h"
 
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
-  auto sw = sentinel_wrapper<int *>(buffer + 8); // Note: not 4, but that's OK.
-
   {
-    const std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView{buffer}, 4);
-    assert(base(tv.end().base()) == base(sw));
-    ASSERT_SAME_TYPE(decltype(tv.end().base()), sentinel_wrapper<int *>);
+    std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView(buffer), 4);
+    std::same_as<sentinel_wrapper<int*>> auto sw1 = tv.end().base();
+    assert(base(sw1) == buffer + 8);
+    std::same_as<sentinel_wrapper<int*>> auto sw2 = std::as_const(tv).end().base();
+    assert(base(sw2) == buffer + 8);
   }
-
-  {
-    std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView{buffer}, 4);
-    assert(base(tv.end().base()) == base(sw));
-    ASSERT_SAME_TYPE(decltype(tv.end().base()), sentinel_wrapper<int *>);
-  }
-
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.take/sentinel/ctor.pass.cpp

 #include "test_iterators.h"
 #include "../types.h"
 
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     // Test the default ctor.
-    std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView{buffer}, 4);
-    assert(decltype(tv.end()){} == std::ranges::next(tv.begin(), 4));
+    using TakeView = std::ranges::take_view<MoveOnlyView>;
+    using Sentinel = std::ranges::sentinel_t<TakeView>;
+    Sentinel s;
+    TakeView tv = TakeView(MoveOnlyView(buffer), 4);
+    assert(tv.begin() + 4 == s);
   }
 
   {
-    std::ranges::take_view<MoveOnlyView> nonConst(MoveOnlyView{buffer}, 5);
-    const std::ranges::take_view<MoveOnlyView> tvConst(MoveOnlyView{buffer}, 5);
-    auto sent1 = nonConst.end();
-    // Convert to const. Note, we cannot go the other way.
-    std::remove_cv_t<decltype(tvConst.end())> sent2 = sent1;
-
-    assert(sent1 == std::ranges::next(tvConst.begin(), 5));
-    assert(sent2 == std::ranges::next(tvConst.begin(), 5));
+    // Test the conversion from "sentinel" to "sentinel-to-const".
+    using TakeView = std::ranges::take_view<MoveOnlyView>;
+    using Sentinel = std::ranges::sentinel_t<TakeView>;
+    using ConstSentinel = std::ranges::sentinel_t<const TakeView>;
+    static_assert(std::is_convertible_v<Sentinel, ConstSentinel>);
+    TakeView tv = TakeView(MoveOnlyView(buffer), 4);
+    Sentinel s = tv.end();
+    ConstSentinel cs = s;
+    cs = s;  // test assignment also
+    assert(tv.begin() + 4 == s);
+    assert(tv.begin() + 4 == cs);
+    assert(std::as_const(tv).begin() + 4 == s);
+    assert(std::as_const(tv).begin() + 4 == cs);
   }
 
   {
-    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 6);
-    auto sw = sentinel_wrapper<int *>(buffer + 6);
-    using Sent = decltype(tv.end());
-    Sent sent = Sent(sw);
-    assert(base(sent.base()) == base(sw));
+    // Test the constructor from "base-sentinel" to "sentinel".
+    using TakeView = std::ranges::take_view<MoveOnlyView>;
+    using Sentinel = std::ranges::sentinel_t<TakeView>;
+    sentinel_wrapper<int*> sw1 = MoveOnlyView(buffer).end();
+    static_assert( std::is_constructible_v<Sentinel, sentinel_wrapper<int*>>);
+    static_assert(!std::is_convertible_v<sentinel_wrapper<int*>, Sentinel>);
+    auto s = Sentinel(sw1);
+    std::same_as<sentinel_wrapper<int*>> auto sw2 = s.base();
+    assert(base(sw2) == base(sw1));
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp

 //            regular_invocable<const F&, range_reference_t<const V>>;
 
 #include <ranges>
 
 #include "test_macros.h"
 #include "types.h"
 
 template<class T>
-concept EndInvocable = requires(T t) { t.end(); };
-
-template<class T>
-concept EndIsIter = requires(T t) { ++t.end(); };
+concept HasConstQualifiedEnd = requires(const T& t) { t.end(); };
 
 constexpr bool test() {
   {
-    std::ranges::transform_view transformView(MoveOnlyView{}, PlusOneMutable{});
-    assert(transformView.end().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<ForwardView, PlusOneMutable>;
+    static_assert(std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<ForwardView>);
+    assert(base(end.base()) == globalBuff + 8);
+    static_assert(!HasConstQualifiedEnd<TransformView>);
   }
-
   {
-    std::ranges::transform_view transformView(ForwardView{}, PlusOneMutable{});
-    assert(transformView.end().base().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<InputView, PlusOneMutable>;
+    static_assert(!std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<InputView>);
+    assert(base(base(end.base())) == globalBuff + 8);
+    static_assert(!HasConstQualifiedEnd<TransformView>);
   }
-
   {
-    std::ranges::transform_view transformView(InputView{}, PlusOneMutable{});
-    assert(transformView.end().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<InputView, PlusOne>;
+    static_assert(!std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<InputView>);
+    assert(base(base(end.base())) == globalBuff + 8);
+    auto cend = std::as_const(tv).end();
+    ASSERT_SAME_TYPE(decltype(cend.base()), std::ranges::sentinel_t<const InputView>);
+    assert(base(base(cend.base())) == globalBuff + 8);
   }
-
   {
-    const std::ranges::transform_view transformView(MoveOnlyView{}, PlusOne{});
-    assert(transformView.end().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<MoveOnlyView, PlusOneMutable>;
+    static_assert(std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<MoveOnlyView>);
+    assert(end.base() == globalBuff + 8);
+    static_assert(!HasConstQualifiedEnd<TransformView>);
+  }
+  {
+    using TransformView = std::ranges::transform_view<MoveOnlyView, PlusOne>;
+    static_assert(std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<MoveOnlyView>);
+    assert(end.base() == globalBuff + 8);
+    auto cend = std::as_const(tv).end();
+    ASSERT_SAME_TYPE(decltype(cend.base()), std::ranges::sentinel_t<const MoveOnlyView>);
+    assert(cend.base() == globalBuff + 8);
   }
-
-  static_assert(!EndInvocable<const std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>);
-  static_assert( EndInvocable<      std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>);
-  static_assert( EndInvocable<const std::ranges::transform_view<MoveOnlyView, PlusOne>>);
-  static_assert(!EndInvocable<const std::ranges::transform_view<InputView, PlusOneMutable>>);
-  static_assert( EndInvocable<      std::ranges::transform_view<InputView, PlusOneMutable>>);
-  static_assert( EndInvocable<const std::ranges::transform_view<InputView, PlusOne>>);
-
-  static_assert(!EndIsIter<const std::ranges::transform_view<InputView, PlusOne>>);
-  static_assert(!EndIsIter<      std::ranges::transform_view<InputView, PlusOneMutable>>);
-  static_assert( EndIsIter<const std::ranges::transform_view<MoveOnlyView, PlusOne>>);
-  static_assert( EndIsIter<      std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>);
-
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp

 
 // transform_view::<iterator>::base
 
 #include <ranges>
 
 #include "test_macros.h"
 #include "../types.h"
 
-template<class V, class F>
-concept BaseInvocable = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
-  iter.base();
+template<class It>
+concept HasBase = requires(It it) {
+  static_cast<It>(it).base();
 };
 
 constexpr bool test() {
   {
-    std::ranges::transform_view<MoveOnlyView, PlusOneMutable> transformView;
-    auto iter = std::move(transformView).begin();
-    ASSERT_SAME_TYPE(int*, decltype(iter.base()));
-    assert(iter.base() == globalBuff);
-    ASSERT_SAME_TYPE(int*, decltype(std::move(iter).base()));
-    assert(std::move(iter).base() == globalBuff);
+    using TransformView = std::ranges::transform_view<MoveOnlyView, PlusOneMutable>;
+    TransformView tv;
+    auto begin = tv.begin();
+    ASSERT_SAME_TYPE(decltype(begin.base()), int*);
+    assert(begin.base() == globalBuff);
+    ASSERT_SAME_TYPE(decltype(std::move(begin).base()), int*);
+    assert(std::move(begin).base() == globalBuff);
   }
-
   {
-    std::ranges::transform_view<InputView, PlusOneMutable> transformView;
-    auto iter = transformView.begin();
-    assert(std::move(iter).base() == globalBuff);
-    ASSERT_SAME_TYPE(cpp20_input_iterator<int *>, decltype(std::move(iter).base()));
+    using TransformView = std::ranges::transform_view<InputView, PlusOneMutable>;
+    TransformView tv;
+    auto begin = tv.begin();
+    static_assert(!HasBase<decltype(begin)&>);
+    static_assert(HasBase<decltype(begin)&&>);
+    static_assert(!HasBase<const decltype(begin)&>);
+    static_assert(!HasBase<const decltype(begin)&&>);
+    std::same_as<cpp20_input_iterator<int *>> auto it = std::move(begin).base();
+    assert(base(it) == globalBuff);
   }
-
-  static_assert(!BaseInvocable<InputView, PlusOneMutable>);
-
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableRange> = true;
 static_assert(!std::ranges::view<BorrowableRange>);
 static_assert( std::ranges::contiguous_range<BorrowableRange>);
 static_assert( std::ranges::borrowed_range<BorrowableRange>);
 
 struct InputView : std::ranges::view_base {
   int *ptr_;
   constexpr explicit InputView(int* ptr = globalBuff) : ptr_(ptr) {}
-  constexpr cpp20_input_iterator<int*> begin() const { return cpp20_input_iterator<int*>(ptr_); }
-  constexpr int *end() const { return ptr_ + 8; }
+  constexpr auto begin() const { return cpp20_input_iterator<int*>(ptr_); }
+  constexpr auto end() const { return sentinel_wrapper<cpp20_input_iterator<int*>>(cpp20_input_iterator<int*>(ptr_ + 8)); }
 };
-// TODO: remove these bogus operators
-constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
+static_assert( std::ranges::view<InputView>);
+static_assert(!std::ranges::sized_range<InputView>);
 
 struct SizedSentinelView : std::ranges::view_base {
   int count_;
   constexpr explicit SizedSentinelView(int count = 8) : count_(count) {}
   constexpr auto begin() const { return RandomAccessIter(globalBuff); }
   constexpr int *end() const { return globalBuff + count_; }
 };
 // TODO: remove these bogus operators