fix test

Author: changkhothuychung

libcxx/include/__ranges/concat_view.h

@@ -74,29 +74,42 @@ template <class... _Tp>
 using __extract_last _LIBCPP_NODEBUG = __extract_last_impl<_Tp...>::type;
 #  endif
 
-template <class _Tp, class... _Tail>
-constexpr bool __derived_from_pack =
-    __derived_from_pack<_Tp, __extract_last<_Tail...>> && __derived_from_pack<_Tail...>;
+template <bool _Const, class... _Tp>
+struct __all_but_first_model_sized_range;
 
-template <class _Tp, class _IterCategory>
-constexpr bool __derived_from_pack<_Tp, _IterCategory> = derived_from<_Tp, _IterCategory>;
+template <bool _Const, class _Head, class... _Tail>
+struct __all_but_first_model_sized_range<_Const, _Head, _Tail...> {
+  static constexpr bool value = (sized_range<__maybe_const<_Const, _Tail>> && ...);
+};
 
-template <class _View, class... _Views>
-struct __last_view : __last_view<_Views...> {};
+template <bool _Const, class... _Views>
+concept __all_random_access = (random_access_range<__maybe_const<_Const, _Views>> && ...);
 
-template <class _View>
-struct __last_view<_View> {
-  using type _LIBCPP_NODEBUG = _View;
-};
+template <bool _Const, class... _Views>
+concept __all_bidirectional = (bidirectional_range<__maybe_const<_Const, _Views>> && ...);
 
-template <bool _Const, class... _Tp>
-struct __apply_drop_first;
+template <bool _Const, class... _Views>
+concept __all_forward = (forward_range<__maybe_const<_Const, _Views>> && ...);
 
-template <bool _Const, class _Head, class... _Tail>
-struct __apply_drop_first<_Const, _Head, _Tail...> {
-  static constexpr bool value = (sized_range<__maybe_const<_Const, _Tail>> && ...);
+template <bool _Const, class _First, class... _Tail>
+struct __all_common_ignore_last {
+  static constexpr bool value =
+      common_range<__maybe_const<_Const, _First>> && __all_common_ignore_last<_Const, _Tail...>::value;
+};
+
+template <bool _Const, class _Tail>
+struct __all_common_ignore_last<_Const, _Tail> {
+  static constexpr bool value = true;
 };
 
+template <bool _Const, class... _Rs>
+concept __concat_is_random_access =
+    (__all_random_access<_Const, _Rs...>) && (__all_common_ignore_last<_Const, _Rs...>::value);
+
+template <bool _Const, class... _Rs>
+concept __concat_is_bidirectional =
+    (__all_bidirectional<_Const, _Rs...>) && (__all_common_ignore_last<_Const, _Rs...>::value);
+
 template <input_range... _Views>
   requires(view<_Views> && ...) && (sizeof...(_Views) > 0) && __concatable<_Views...>
 class concat_view : public view_interface<concat_view<_Views...>> {
@@ -129,7 +142,7 @@ class concat_view : public view_interface<concat_view<_Views...>> {
   _LIBCPP_HIDE_FROM_ABI constexpr auto end()
     requires(!(__simple_view<_Views> && ...))
   {
-    if constexpr (common_range<__maybe_const<false, typename __last_view<_Views...>::type>>) {
+    if constexpr (common_range<__maybe_const<false, __extract_last<_Views...>>>) {
       constexpr auto __n = sizeof...(_Views);
       return __iterator<false>(this, in_place_index<__n - 1>, ranges::end(std::get<__n - 1>(__views_)));
     } else {
@@ -140,7 +153,7 @@ class concat_view : public view_interface<concat_view<_Views...>> {
   _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
     requires(range<const _Views> && ...)
   {
-    if constexpr (common_range<__maybe_const<true, typename __last_view<_Views...>::type>>) {
+    if constexpr (common_range<__maybe_const<true, __extract_last<_Views...>>>) {
       constexpr auto __n = sizeof...(_Views);
       return __iterator<true>(this, in_place_index<__n - 1>, ranges::end(std::get<__n - 1>(__views_)));
     } else {
@@ -176,14 +189,14 @@ template <bool _Const, typename... _Views>
 struct __concat_view_iterator_category<_Const, _Views...> {
 private:
   constexpr static bool __derive_pack_random_iterator =
-      __derived_from_pack<typename iterator_traits<iterator_t<__maybe_const<_Const, _Views>>>::iterator_category...,
-                          random_access_iterator_tag>;
+      (derived_from<typename iterator_traits<iterator_t<__maybe_const<_Const, _Views>>>::iterator_category,
+                          random_access_iterator_tag> && ...);
   constexpr static bool __derive_pack_bidirectional_iterator =
-      __derived_from_pack<typename iterator_traits<iterator_t<__maybe_const<_Const, _Views>>>::iterator_category...,
-                          bidirectional_iterator_tag>;
+      (derived_from<typename iterator_traits<iterator_t<__maybe_const<_Const, _Views>>>::iterator_category,
+                          bidirectional_iterator_tag> && ...);
   constexpr static bool __derive_pack_forward_iterator =
-      __derived_from_pack<typename iterator_traits< iterator_t<__maybe_const<_Const, _Views>>>::iterator_category...,
-                          forward_iterator_tag>;
+      (derived_from<typename iterator_traits< iterator_t<__maybe_const<_Const, _Views>>>::iterator_category,
+                          forward_iterator_tag> && ...);
 
 public:
   using iterator_category =
@@ -573,7 +586,7 @@ class concat_view<_Views...>::__iterator : public __concat_view_iterator_categor
   _LIBCPP_HIDE_FROM_ABI 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>>> &&
              ...) &&
-            (__apply_drop_first<_Const, _Views...>::value)
+            (__all_but_first_model_sized_range<_Const, _Views...>::value)
   {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
         !__x.__it_.valueless_by_exception(),
@@ -595,7 +608,7 @@ class concat_view<_Views...>::__iterator : public __concat_view_iterator_categor
   _LIBCPP_HIDE_FROM_ABI 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>>> &&
              ...) &&
-            (__apply_drop_first<_Const, _Views...>::value)
+            (__all_but_first_model_sized_range<_Const, _Views...>::value)
   {
     return -(__x - default_sentinel);
   }

libcxx/include/__ranges/concepts.h

@@ -172,33 +172,7 @@ concept __concatable = requires {
   typename __concat_rvalue_reference_t<_Rs...>;
 } && __concat_indirectly_readable<_Rs...>;
 
-template <bool _Const, class... _Views>
-concept __all_random_access = (random_access_range<__maybe_const<_Const, _Views>> && ...);
 
-template <bool _Const, class... _Views>
-concept __all_bidirectional = (bidirectional_range<__maybe_const<_Const, _Views>> && ...);
-
-template <bool _Const, class... _Views>
-concept __all_forward = (forward_range<__maybe_const<_Const, _Views>> && ...);
-
-template <bool _Const, class _First, class... _Tail>
-struct __all_common_ignore_last {
-  static constexpr bool value =
-      common_range<__maybe_const<_Const, _First>> && __all_common_ignore_last<_Const, _Tail...>::value;
-};
-
-template <bool _Const, class _Tail>
-struct __all_common_ignore_last<_Const, _Tail> {
-  static constexpr bool value = true;
-};
-
-template <bool _Const, class... _Rs>
-concept __concat_is_random_access =
-    (__all_random_access<_Const, _Rs...>) && (__all_common_ignore_last<_Const, _Rs...>::value);
-
-template <bool _Const, class... _Rs>
-concept __concat_is_bidirectional =
-    (__all_bidirectional<_Const, _Rs...>) && (__all_common_ignore_last<_Const, _Rs...>::value);
 
 #  endif // _LIBCPP_STD_VER >= 23
 

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

@@ -13,20 +13,81 @@
 
 #include <cassert>
 #include "test_iterators.h"
+#include "types.h"
 
-constexpr void general_tests() {
-  std::vector<int> v1 = {1, 2, 3, 4, 5, 6, 7, 8};
-  std::vector<int> v2 = {1, 2, 3, 4, 5, 6, 7, 8};
-  // Check the return type of `.begin()`
+template <class T>
+concept HasConstBegin = requires(const T& ct) { ct.begin(); };
+
+template <class T>
+concept HasBegin = requires(T& t) { t.begin(); };
+
+template <class T>
+concept HasConstAndNonConstBegin =
+    HasConstBegin<T> &&
+    requires(T& t, const T& ct) { requires !std::same_as<decltype(t.begin()), decltype(ct.begin())>; };
+
+template <class T>
+concept HasOnlyNonConstBegin = HasBegin<T> && !
+HasConstBegin<T>;
+
+template <class T>
+concept HasOnlyConstBegin = HasConstBegin<T> && !
+HasConstAndNonConstBegin<T>;
+
+constexpr void tests() {
+  
+  // check the case of simple view
+  {
+    int buffer[4] = {1, 2, 3, 4};
+    std::ranges::concat_view v(SimpleCommon{buffer}, SimpleCommon{buffer});
+    static_assert(std::is_same_v<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+    assert(v.begin() == std::as_const(v).begin());
+
+    using View = decltype(v);
+    static_assert(HasOnlyConstBegin<View>);
+    static_assert(!HasOnlyNonConstBegin<View>);
+    static_assert(!HasConstAndNonConstBegin<View>);
+  }
+
+  // not all underlying ranges model simple view
   {
+    int buffer[4] = {1, 2, 3, 4};
+    std::ranges::concat_view v(SimpleCommon{buffer}, NonSimpleNonCommon{buffer});
+    static_assert(!std::is_same_v<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+    assert(v.begin() == std::as_const(v).begin());
+
+    using View = decltype(v);
+    static_assert(!HasOnlyConstBegin<View>);
+    static_assert(!HasOnlyNonConstBegin<View>);
+    static_assert(HasConstAndNonConstBegin<View>);
+  }
+
+  // first view is empty
+  {
+    std::vector<int> v1;
+    std::vector<int> v2 = {1, 2, 3, 4};
     std::ranges::concat_view view(v1, v2);
-    using ConcatIterator = std::ranges::iterator_t<decltype(view)>;
-    ASSERT_SAME_TYPE(ConcatIterator, decltype(view.begin()));
+    auto it = view.begin();
+    assert(*it == 1);
+    assert(it + 4 == view.end());
   }
+
+  // first few views is empty
+  {
+    std::vector<int> v1;
+    std::vector<int> v2;
+    std::vector<int> v3 = {1, 2, 3, 4};
+    std::ranges::concat_view view(v1, v2, v3);
+    auto it = view.begin();
+    assert(*it == 1);
+    assert(it + 4 == view.end());
+  }
+
+
 }
 
 constexpr bool test() {
-  general_tests();
+  tests();
   return true;
 }
 

libcxx/test/std/ranges/range.adaptors/range.concat/ctor.default.verify.cpp renamed to libcxx/test/std/ranges/range.adaptors/range.concat/constraints.verify.cpp

@@ -43,6 +43,14 @@ constexpr bool test() {
     static_assert(std::is_same_v<decltype(view), std::ranges::concat_view<std::ranges::ref_view<Range>>>);
   }
 
+  // Test a view which has a range and a view
+  {
+    Range r;
+    View v;
+    std::ranges::concat_view view(r, v);
+    static_assert(std::is_same_v<decltype(view), std::ranges::concat_view<std::ranges::ref_view<Range>, View>>);
+  }
+
   return true;
 }
 

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

@@ -39,7 +39,17 @@ struct NoexceptView : std::ranges::view_base {
   int const* end() const;
 };
 
-constexpr bool test() {
+struct HelperView : std::ranges::view_base {
+  constexpr HelperView(const int* begin, const int *end) : begin_(begin), end_(end) {}
+  constexpr int const* begin() const { return begin_; }
+  constexpr int const* end() const { return end_; }
+
+private:
+  int const* begin_;
+  int const* end_;
+};
+
+constexpr void test_with_one_view() {
   {
     using View = std::ranges::concat_view<DefaultConstructibleView>;
     View view;
@@ -51,6 +61,30 @@ constexpr bool test() {
     assert(*it++ == 4);
     assert(it == end);
   }
+}
+
+constexpr void test_with_more_than_one_view() {
+  {
+    using View = std::ranges::concat_view<HelperView, HelperView>;
+    int arr1[] = {1,2};
+    int arr2[] = {3,4};
+    HelperView range1(arr1, arr1 + 2);
+    HelperView range2(arr2, arr2 + 2);
+    View view(range1, range2);
+    auto it  = view.begin();
+    auto end = view.end();
+    assert(*it++ == 1);
+    assert(*it++ == 2);
+    assert(*it++ == 3);
+    assert(*it++ == 4);
+    assert(it == end);
+  }
+}
+
+constexpr bool tests()
+{
+  test_with_one_view();
+  test_with_more_than_one_view();
 
   // Check cases where the default constructor isn't provided
   {
@@ -73,8 +107,8 @@ constexpr bool test() {
 }
 
 int main(int, char**) {
-  test();
-  static_assert(test());
+  tests();
+  static_assert(tests());
 
   return 0;
 }

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

@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: std-at-least-c++26
+
+#include <cassert>
+#include <ranges>
+#include <vector>
+#include "test_macros.h"
+
+int main(int, char**) {
+  std::vector<int> v{1, 2, 3};
+  auto r = std::views::counted(std::back_inserter(v), 3);
+  auto c = std::views::concat(r);
+  // expected-error@*:* {{}}
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.concat/ctor.verify.cpp

@@ -24,19 +24,28 @@ struct Range : std::ranges::view_base {
   int* end_;
 };
 
-struct TrackingRange : TrackInitialization, std::ranges::view_base {
-  using TrackInitialization::TrackInitialization;
-  int* begin() const;
-  int* end() const;
+struct MoveAwareView : std::ranges::view_base {
+  int moves = 0;
+  constexpr MoveAwareView() = default;
+  constexpr MoveAwareView(MoveAwareView&& other) : moves(other.moves + 1) { other.moves = 1; }
+  constexpr MoveAwareView& operator=(MoveAwareView&& other) {
+    moves = other.moves + 1;
+    other.moves = 0;
+    return *this;
+  }
+  constexpr const int* begin() const { return &moves; }
+  constexpr const int* end() const { return &moves + 1; }
 };
 
 constexpr bool test() {
-  int buff[] = {1, 2, 3, 4};
+  int buff[] = {1, 2};
+  int buff2[] = {3, 4};
 
-  // Test explicit syntax
+  // constructor from views
   {
-    Range range(buff, buff + 4);
-    std::ranges::concat_view<Range> view(range);
+    Range range(buff, buff + 2);
+    Range range2(buff2, buff2 + 2);
+    std::ranges::concat_view view(range, range2);
     auto it  = view.begin();
     auto end = view.end();
     assert(*it++ == 1);
@@ -48,11 +57,11 @@ constexpr bool test() {
 
   // Make sure we move the view
   {
-    bool moved = false, copied = false;
-    TrackingRange range(&moved, &copied);
-    [[maybe_unused]] std::ranges::concat_view<TrackingRange> view(std::move(range));
-    assert(moved);
-    assert(!copied);
+    MoveAwareView mv;
+    std::ranges::concat_view v{std::move(mv), MoveAwareView{}};
+    auto it = v.begin();
+    assert(*it++ == 2); // one move from the local variable to parameter, one move from parameter to member
+    assert(*it++ == 1);
   }
 
   return true;