add tests for drop_view and join_view

[huixie90]

sorry. I meant to add these tests as per requested in https://reviews.llvm.org/D116808.
But somehow this ends up as a new review. How can I merge those two reviews?
@philnik

[philnik]

If you are using arc you have to arc diff `git merge-base origin/main HEAD` --update D116808 and just abandon this revision.

libcxx/test/std/ranges/range.adaptors/range.drop/begin.pass.cpp

 //   requires (!(simple-view<V> &&
 //               random_access_range<const V> && sized_range<const V>));
 // constexpr auto begin() const
 //   requires random_access_range<const V> && sized_range<const V>;
 
 #include <ranges>
 
 #include "test_macros.h"
+#include "test_iterators.h"
 #include "types.h"
 
 template<class T>
 concept BeginInvocable = requires(std::ranges::drop_view<T> t) { t.begin(); };
 
+struct SimpleView : std::ranges::view_base {
+  bool non_const_begin_called{false};
+  constexpr int* begin() {
+    non_const_begin_called = true;
+    return nullptr;
+  }
+  constexpr int* begin() const { return nullptr; }
+  constexpr int* end() const { return nullptr; }
+  constexpr std::size_t size() const { return 0u; }
+};
+
+struct NonSimpleView : std::ranges::view_base {
+  int* begin();
+  const int* begin() const;
+  int* end();
+  const int* end() const;
+  std::size_t size() const;
+};
+
 constexpr bool test() {
   // random_access_range<const V> && sized_range<const V>
   std::ranges::drop_view dropView1(MoveOnlyView(), 4);
   assert(dropView1.begin() == globalBuff + 4);
 
   // !random_access_range<const V>
   std::ranges::drop_view dropView2(ForwardView(), 4);
   assert(dropView2.begin().base() == globalBuff + 4);
constexpr bool test() {
   std::ranges::drop_view dropView8(view8, 5);
   assert(dropView8.begin().base().base() == globalBuff + 5);
   assert(dropView8.begin().stride_count() == 5);
   assert(dropView8.begin().base().base() == globalBuff + 5);
   assert(dropView8.begin().stride_count() == 5);
 
   static_assert(!BeginInvocable<const ForwardView>);
 
+  // simple_view<V> && random_access_range<const V> && sized_range<const V>
+  {
+    std::ranges::drop_view dropView(SimpleView{}, 4);
+    dropView.begin();
+    assert(!dropView.base().non_const_begin_called);
+  }
+
+  // !simple_view<V> && random_access_range<const V> && sized_range<const V>
+  {
+    using DropView = std::ranges::drop_view<NonSimpleView>;
+    static_assert(std::same_as<decltype(std::declval<DropView&>().begin()), int*>);
+    static_assert(std::same_as<decltype(std::declval<const DropView&>().begin()), const int*>);
+  }
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 // constexpr auto begin() const;
 
 #include <cassert>
 #include <ranges>
 
 #include "test_macros.h"
 #include "types.h"
 
+struct SimpleParentView : std::ranges::view_base {
+  const ChildView* begin() const;
+  const ChildView* end() const;
+};
+
 constexpr bool test() {
   int buffer[4][4] = {{1111, 2222, 3333, 4444}, {555, 666, 777, 888}, {99, 1010, 1111, 1212}, {13, 14, 15, 16}};
 
   {
     ChildView children[4] = {ChildView(buffer[0]), ChildView(buffer[1]), ChildView(buffer[2]), ChildView(buffer[3])};
     auto jv = std::ranges::join_view(ParentView{children});
     assert(*jv.begin() == 1111);
   }
// Last child is empty, others are not.
     assert(*jv.begin() == 1111);
   }
 
   {
     const std::ranges::join_view jv(buffer);
     assert(*jv.begin() == 1111);
   }
 
+  // !simple-view<V>
+  {
+    using WithNonSimpleBase = std::ranges::join_view<ParentView<ChildView>>;
+    static_assert(!std::same_as<decltype(std::declval<WithNonSimpleBase&>().begin()),
+                                decltype(std::declval<WithNonSimpleBase const&>().begin())>);
+  }
+
+  // simple-view<V> && is_reference_v<range_reference_t<V>>;
+  {
+    using WithSimpleBase = std::ranges::join_view<SimpleParentView>;
+    static_assert(std::same_as<decltype(std::declval<WithSimpleBase&>().begin()),
+                               decltype(std::declval<WithSimpleBase const&>().begin())>);
+  }
+
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }