[libc++] Various cleanups in the ranges tests

[ldionne]

Summary

• Rename test files to follow conventions better
• Split constructor tests that were in a single file
• Add missing tests for take_view and transform_view's default constructors
• Add missing tests for transform_view's view/function constructor
• Fix include guards
• Mark some tests as being specific to libc++

[• Quuxplusone]

Just skimmed, but it LGTM.

Might you be persuaded to do another cleanup patch replacing all the instances of stdr:: with std::ranges::? Two days ago I was grepping for the ranges::iterator_t tests, and was mildly irked to find we "didn't have any" (because we had stdr::iterator_t instead).

libcxx/test/std/ranges/range.access/range.access.begin/incomplete.verify.cpp

15

Grammar nit (throughout): "types" should be "type", since it's an array of (one single) incomplete type.

22–24

It might be more to the point to make this an actual SFINAE situation, like

template<class T> void f() requires std::invocable<begin_t&, T> {}
template<class T> void f() {}

https://godbolt.org/z/deP98eMvd

Also, calling this 48-line spew a "better" diagnostic is... generous. ;)

29

Tangent: Maybe the message shouldn't end with a period .

[ldionne]

libcxx/test/std/ranges/range.access/range.access.begin/incomplete.verify.cpp

22–24

I'll suggest that we tackle whether or not we want this behavior at all as a separate patch.

[ldionne]

Address review comments

libcxx/test/std/ranges/range.access/range.access.begin/incomplete.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
+// REQUIRES: libc++
 
-// unspecified begin;
+// Test the libc++ specific behavior that we provide a better diagnostic when calling
+// std::ranges::begin on an array of incomplete type.
 
 #include <ranges>
 
 #include <type_traits>
 
 using begin_t = decltype(std::ranges::begin);
 
-template <class T>
-requires(!std::invocable<begin_t&, T>)
-void f() {}
+template <class T> void f() requires std::invocable<begin_t&, T> { }
+template <class T> void f() { }
 
 void test() {
   struct incomplete;
   f<incomplete(&)[]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@-2 {{no matching function for call to 'f'}}
   f<incomplete(&)[10]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@-2 {{no matching function for call to 'f'}}
   f<incomplete(&)[2][2]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@-2 {{no matching function for call to 'f'}}
 
   // This is okay because calling `std::ranges::begin` on any rvalue is ill-formed.
   f<incomplete(&&)[10]>();
 }

libcxx/test/std/ranges/range.access/range.access.cbegin/incomplete.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
+// REQUIRES: libc++
 
-// ranges::cbegin;
+// Test the libc++ specific behavior that we provide a better diagnostic when calling
+// std::ranges::cbegin on an array of incomplete type.
 
 #include <ranges>
 
 #include <type_traits>
 
 using cbegin_t = decltype(std::ranges::cbegin);
 
-template <class T>
-requires(!std::invocable<cbegin_t&, T>)
-void f() {}
+template <class T> void f() requires std::invocable<cbegin_t&, T> { }
+template <class T> void f() { }
 
 void test() {
   struct incomplete;
   f<incomplete(&)[10]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@-2 {{no matching function for call to 'f'}}
 
   // This is okay because calling `std::ranges::end` on any rvalue is ill-formed.
   f<incomplete(&&)[10]>();
 }

libcxx/test/std/ranges/range.access/range.access.cend/incomplete.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
+// REQUIRES: libc++
 
-// unspecified begin;
+// Test the libc++ specific behavior that we provide a better diagnostic when calling
+// std::ranges::cend on an array of incomplete type.
 
 #include <ranges>
 
 #include <type_traits>
 
 using cend_t = decltype(std::ranges::cend);
 
-template <class T>
-requires(!std::invocable<cend_t&, T>)
-void f() {}
+template <class T> void f() requires std::invocable<cend_t&, T> { }
+template <class T> void f() { }
 
 void test() {
   struct incomplete;
   f<incomplete(&)[]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
   // expected-error@*:* {{"`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type."}}
   f<incomplete(&)[10]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
   // expected-error@*:* {{"`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@-3 {{no matching function for call to 'f'}}
   f<incomplete(&)[2][2]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@-2 {{no matching function for call to 'f'}}
 
   // This is okay because calling `std::ranges::end` on any rvalue is ill-formed.
   f<incomplete(&&)[10]>();
 }

libcxx/test/std/ranges/range.access/range.access.end/incomplete.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
+// REQUIRES: libc++
 
-// unspecified begin;
+// Test the libc++ specific behavior that we provide a better diagnostic when calling
+// std::ranges::end on an array of incomplete type.
 
 #include <ranges>
 
 #include <type_traits>
 
 using end_t = decltype(std::ranges::end);
 
-template <class T>
-requires(!std::invocable<end_t&, T>)
-void f() {}
+template <class T> void f() requires std::invocable<end_t&, T> { }
+template <class T> void f() { }
 
 void test() {
   struct incomplete;
   f<incomplete(&)[]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
   // expected-error@*:* {{"`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type."}}
   f<incomplete(&)[10]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
   // expected-error@*:* {{"`std::ranges::end` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@-3 {{no matching function for call to 'f'}}
   f<incomplete(&)[2][2]>();
   // expected-error@*:* {{"`std::ranges::begin` is SFINAE-unfriendly on arrays of an incomplete type."}}
-  // expected-error@-2 {{no matching function for call to 'f'}}
 
   // This is okay because calling `std::ranges::end` on any rvalue is ill-formed.
   f<incomplete(&&)[10]>();
 }

libcxx/test/std/ranges/range.access/range.prim/data.incomplete.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
+// REQUIRES: libc++
 
-// std::ranges::data
+// Test the libc++ specific behavior that we provide a better diagnostic when calling
+// std::ranges::data on an array of incomplete type.
 
 #include <ranges>
 
 struct Incomplete;
 
 void f(Incomplete arr[]) {
   // expected-error@*:* {{is SFINAE-unfriendly on arrays of an incomplete type.}}
   // expected-error@*:* {{no matching function for call}}

libcxx/test/std/ranges/range.access/range.prim/empty.incomplete.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
+// REQUIRES: libc++
 
-// std::ranges::empty
+// Test the libc++ specific behavior that we provide a better diagnostic when calling
+// std::ranges::empty on an array of incomplete type.
 
 #include <ranges>
 
 struct Incomplete;
 
 void f(Incomplete arr[]) {
   // expected-error@*:* {{is SFINAE-unfriendly on arrays of an incomplete type.}}
   // expected-error@*:* {{call to deleted function call operator in type}}

libcxx/test/std/ranges/range.adaptors/range.drop/dangling.cache.pass.cpp

struct ZeroOnDestroy : std::ranges::view_base {
   int buff[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   constexpr ForwardIter begin() { return ForwardIter(buff); }
   constexpr ForwardIter begin() const { return ForwardIter(); }
   constexpr ForwardIter end() { return ForwardIter(buff + 8); }
   constexpr ForwardIter end() const { return ForwardIter(); }
 
   ~ZeroOnDestroy() {
-    memset(buff, 0, sizeof(buff));
+    std::memset(buff, 0, sizeof(buff));
   }
 
   static auto dropFirstFour() {
     ZeroOnDestroy zod;
     std::ranges::drop_view dv(zod, 4);
     // Make sure we call begin here so the next call to begin will
     // use the cached iterator.
     assert(*dv.begin() == 5);

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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // constexpr explicit join_view(V base);
 
 #include <cassert>
 #include <ranges>
 
 #include "test_macros.h"
 #include "types.h"
 
 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(std::move(jv).base().ptr_ == children);
   }
 
   {
     std::ranges::join_view jv(buffer);
     assert(jv.base().base() == buffer + 0);
   }
 
   {
     // Test explicitness.
     static_assert( std::is_constructible_v<std::ranges::join_view<ParentView<ChildView>>, ParentView<ChildView>>);
     static_assert(!std::is_convertible_v<std::ranges::join_view<ParentView<ChildView>>, ParentView<ChildView>>);
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// take_view() requires default_initializable<V> = default;
+
+#include <ranges>
+#include <cassert>
+
+int buff[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+struct DefaultConstructible : std::ranges::view_base {
+  constexpr DefaultConstructible() : begin_(buff), end_(buff + 8) { }
+  constexpr int const* begin() const { return begin_; }
+  constexpr int const* end() const { return end_; }
+private:
+  int const* begin_;
+  int const* end_;
+};
+
+struct NonDefaultConstructible : std::ranges::view_base {
+  NonDefaultConstructible() = delete;
+  int* begin() const;
+  int* end() const;
+};
+
+constexpr bool test() {
+  {
+    std::ranges::take_view<DefaultConstructible> tv;
+    assert(tv.begin() == buff);
+    assert(tv.size() == 0);
+  }
+
+  // Test SFINAE-friendliness
+  {
+    static_assert( std::is_default_constructible_v<std::ranges::take_view<DefaultConstructible>>);
+    static_assert(!std::is_default_constructible_v<std::ranges::take_view<NonDefaultConstructible>>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// take_view() requires default_initializable<V> = default;
 // constexpr take_view(V base, range_difference_t<V> count);
 
 #include <ranges>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_range.h"
 #include "types.h"
 
-int globalBuffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
-
-template<bool IsDefaultCtorable>
-struct DefaultConstructible : std::ranges::view_base {
-  DefaultConstructible() requires IsDefaultCtorable = default;
-  DefaultConstructible(int*);
-  int* begin();
-  sentinel_wrapper<int*> end();
-};
-
-struct SizedRandomAccessViewToGlobal : std::ranges::view_base {
-  RandomAccessIter begin() { return RandomAccessIter(globalBuffer); }
-  RandomAccessIter begin() const { return RandomAccessIter(globalBuffer); }
-  sentinel_wrapper<RandomAccessIter> end() {
-    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(globalBuffer + 8)};
-  }
-  sentinel_wrapper<RandomAccessIter> end() const {
-    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(globalBuffer + 8)};
-  }
-};
-
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 0);
     assert(tv.base().ptr_ == buffer);
     assert(tv.begin() == tv.end()); // Checking we have correct size.
   }
constexpr bool test() {
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
-  // Tests for the default ctor.
-  static_assert( std::default_initializable<DefaultConstructible<true>>);
-  static_assert(!std::default_initializable<DefaultConstructible<false>>);
-
-  std::ranges::take_view<SizedRandomAccessViewToGlobal> tv;
-  assert(*tv.base().begin() == 1);
-  assert(tv.size() == 0);
-
   return 0;
 }

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

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// transform_view() requires std::default_initializable<V> &&
+//                           std::default_initializable<F> = default;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+
+constexpr int buff[] = {1, 2, 3};
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  constexpr DefaultConstructibleView() : begin_(buff), end_(buff + 3) { }
+  constexpr int const* begin() const { return begin_; }
+  constexpr int const* end() const { return end_; }
+private:
+  int const* begin_;
+  int const* end_;
+};
+
+struct DefaultConstructibleFunction {
+  int state_;
+  constexpr DefaultConstructibleFunction() : state_(100) { }
+  constexpr int operator()(int i) const { return i + state_; }
+};
+
+struct NoDefaultView : std::ranges::view_base {
+  NoDefaultView() = delete;
+  int* begin() const;
+  int* end() const;
+};
+
+struct NoDefaultFunction {
+  NoDefaultFunction() = delete;
+  constexpr int operator()(int i) const;
+};
+
+constexpr bool test() {
+  {
+    std::ranges::transform_view<DefaultConstructibleView, DefaultConstructibleFunction> view;
+    assert(view.size() == 3);
+    assert(view[0] == 101);
+    assert(view[1] == 102);
+    assert(view[2] == 103);
+  }
+
+  {
+    std::ranges::transform_view<DefaultConstructibleView, DefaultConstructibleFunction> view = {};
+    assert(view.size() == 3);
+    assert(view[0] == 101);
+    assert(view[1] == 102);
+    assert(view[2] == 103);
+  }
+
+  static_assert(!std::is_default_constructible_v<std::ranges::transform_view<NoDefaultView,            DefaultConstructibleFunction>>);
+  static_assert(!std::is_default_constructible_v<std::ranges::transform_view<DefaultConstructibleView, NoDefaultFunction>>);
+  static_assert(!std::is_default_constructible_v<std::ranges::transform_view<NoDefaultView,            NoDefaultFunction>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.transform/ctor.view_function.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr transform_view(View, F);
+
+#include <ranges>
+
+#include <cassert>
+
+struct Range : std::ranges::view_base {
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) { }
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+struct F {
+  constexpr int operator()(int i) const { return i + 100; }
+};
+
+constexpr bool test() {
+  int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    Range range(buff, buff + 8);
+    F f;
+    std::ranges::transform_view<Range, F> view(range, f);
+    assert(view[0] == 101);
+    assert(view[1] == 102);
+    // ...
+    assert(view[7] == 108);
+  }
+
+  {
+    Range range(buff, buff + 8);
+    F f;
+    std::ranges::transform_view<Range, F> view = {range, f};
+    assert(view[0] == 101);
+    assert(view[1] == 102);
+    // ...
+    assert(view[7] == 108);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
 #ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H
 #define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_range.h"
 
 int globalBuff[8] = {0,1,2,3,4,5,6,7};

libcxx/test/std/ranges/range.req/range.range/borrowed_range.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class T>
 // concept borrowed_range;
 
 #include <ranges>
 
 struct NotRange {
   int begin() const;
   int end() const;
 };
 
 struct Range {
   int *begin();
   int *end();
 };
 
 struct ConstRange {
   int *begin() const;
   int *end() const;
 };
 
 struct BorrowedRange {
   int *begin() const;
   int *end() const;
 };
 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
 
 static_assert(!std::ranges::borrowed_range<NotRange>);
 static_assert(!std::ranges::borrowed_range<NotRange&>);
 static_assert(!std::ranges::borrowed_range<const NotRange>);
 static_assert(!std::ranges::borrowed_range<const NotRange&>);
 static_assert(!std::ranges::borrowed_range<NotRange&&>);
 
 static_assert(!std::ranges::borrowed_range<Range>);
 static_assert( std::ranges::borrowed_range<Range&>);
 static_assert(!std::ranges::borrowed_range<const Range>);
 static_assert(!std::ranges::borrowed_range<const Range&>);
 static_assert(!std::ranges::borrowed_range<Range&&>);
 
 static_assert(!std::ranges::borrowed_range<ConstRange>);
 static_assert( std::ranges::borrowed_range<ConstRange&>);
 static_assert(!std::ranges::borrowed_range<const ConstRange>);
 static_assert( std::ranges::borrowed_range<const ConstRange&>);
 static_assert(!std::ranges::borrowed_range<ConstRange&&>);
 
 static_assert( std::ranges::borrowed_range<BorrowedRange>);
 static_assert( std::ranges::borrowed_range<BorrowedRange&>);
 static_assert( std::ranges::borrowed_range<const BorrowedRange>);
 static_assert( std::ranges::borrowed_range<const BorrowedRange&>);
 static_assert( std::ranges::borrowed_range<BorrowedRange&&>);

libcxx/test/std/ranges/range.req/range.range/borrowed_range.subsumption.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class T>
 // concept borrowed_range;
 
 #include <ranges>
 
 template <std::ranges::range R>
 consteval bool check_subsumption() {
   return false;
 }
 
 template <std::ranges::borrowed_range R>
 consteval bool check_subsumption() {
   return true;
 }
 
 static_assert(check_subsumption<int (&)[8]>());

libcxx/test/std/ranges/range.utility/range.subrange/advance.pass.cpp

 
 // class std::ranges::subrange;
 
 #include <ranges>
 
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
-#include "../subrange_test_types.h"
+#include "types.h"
 
 constexpr bool test() {
   std::ranges::subrange<int*> a(globalBuff, globalBuff + 8, 8);
   auto a1 = a.next();
   assert(a1.begin() == globalBuff + 1);
   assert(a1.size() == 7);
   auto a5 = a.next(5);
   assert(a5.begin() == globalBuff + 5);

libcxx/test/std/ranges/range.utility/range.subrange/ctor.begin_end.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // class std::ranges::subrange;
 
 #include <ranges>
 
-#include "../subrange_test_types.h"
+#include "types.h"
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 // convertible-to-non-slicing cases:
 //   1. Not convertible (fail)
 //   2. Only one is a pointer (succeed)
 //   3. Both are not pointers (succeed)

libcxx/test/std/ranges/range.utility/range.subrange/ctor.begin_end_size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // class std::ranges::subrange;
 
 #include <ranges>
 
-#include "../subrange_test_types.h"
+#include "types.h"
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 // convertible-to-non-slicing cases:
 //   1. Not convertible (fail)
 //   2. Only one is a pointer (succeed)
 //   3. Both are not pointers (succeed)

libcxx/test/std/ranges/range.utility/range.subrange/ctor.pair_like_conv.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // class std::ranges::subrange;
 
 #include <ranges>
 
-#include "../subrange_test_types.h"
+#include "types.h"
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 #include <tuple>
 #include <utility>
 
 static_assert( std::is_convertible_v<ForwardSubrange, std::pair<ForwardIter, ForwardIter>>);
 static_assert( std::is_convertible_v<ForwardSubrange, std::tuple<ForwardIter, ForwardIter>>);

libcxx/test/std/ranges/range.utility/range.subrange/ctor.range.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // class std::ranges::subrange;
 
 #include <ranges>
 
-#include "../subrange_test_types.h"
+#include "types.h"
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
 
 static_assert( std::is_constructible_v<ForwardSubrange, ForwardBorrowedRange>); // Default case.
 static_assert(!std::is_constructible_v<ForwardSubrange, ForwardRange>); // Not borrowed.
 // Iter convertible to sentinel (pointer) type.
 static_assert( std::is_constructible_v<ConvertibleForwardSubrange, ConvertibleForwardBorrowedRange>);

libcxx/test/std/ranges/range.utility/range.subrange/ctor.range_size.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<borrowed_range R>
+//   requires convertible-to-non-slicing<iterator_t<R>, I> &&
+//            convertible_to<sentinel_t<R>, S>
+// constexpr subrange(R&& r, make-unsigned-like-t<iter_difference_t<I>> n)
+//   requires (K == subrange_kind::sized);
+
+#include <ranges>
+#include <cassert>
+
+struct BorrowedRange {
+  constexpr explicit BorrowedRange(int* b, int* e) : begin_(b), end_(e) { }
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
+namespace std::ranges {
+  template <>
+  inline constexpr bool enable_borrowed_range<::BorrowedRange> = true;
+}
+
+constexpr bool test() {
+  int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
+  using Subrange = std::ranges::subrange<int*, int*, std::ranges::subrange_kind::sized>;
+
+  // Test with an empty range
+  {
+    BorrowedRange range(buff, buff);
+    Subrange subrange(range, 0);
+    assert(subrange.size() == 0);
+  }
+
+  // Test with non-empty ranges
+  {
+    BorrowedRange range(buff, buff + 1);
+    Subrange subrange(range, 1);
+    assert(subrange.size() == 1);
+  }
+  {
+    BorrowedRange range(buff, buff + 2);
+    Subrange subrange(range, 2);
+    assert(subrange[0] == 1);
+    assert(subrange[1] == 2);
+    assert(subrange.size() == 2);
+  }
+  {
+    BorrowedRange range(buff, buff + 8);
+    Subrange subrange(range, 8);
+    assert(subrange[0] == 1);
+    assert(subrange[1] == 2);
+    // ...
+    assert(subrange[7] == 8);
+    assert(subrange.size() == 8);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.utility/range.subrange/ctor/range_size.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: libcpp-has-no-incomplete-ranges
-
-// class std::ranges::subrange;
-
-#include <ranges>
-
-// Tested in pair_like_conv.pass.cpp.
-
-int main(int, char**) {
-  return 0;
-}

libcxx/test/std/ranges/range.utility/range.subrange/get.pass.cpp

 
 // class std::ranges::subrange;
 
 #include <ranges>
 
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
-#include "../subrange_test_types.h"
+#include "types.h"
 
 template<size_t I, class S>
 concept GetInvocable = requires {
   std::get<I>(std::declval<S>());
 };
 
 static_assert( GetInvocable<0, std::ranges::subrange<int*>>);
 static_assert( GetInvocable<1, std::ranges::subrange<int*>>);

libcxx/test/std/ranges/range.utility/range.subrange/primitives.pass.cpp

 
 // class std::ranges::subrange;
 
 #include <ranges>
 
 #include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
-#include "../subrange_test_types.h"
-
-// Note: begin and end tested in range.subrange.ctor.pass.cpp.
+#include "types.h"
 
 constexpr bool test() {
   std::ranges::subrange<MoveOnlyForwardIter, int*> a(MoveOnlyForwardIter(globalBuff), globalBuff + 8, 8);
   assert(a.begin().base == globalBuff);
   assert(!a.empty());
   assert(a.size() == 8);
 
   std::ranges::subrange<ForwardIter> b(ForwardIter(nullptr), ForwardIter(nullptr));

libcxx/test/std/ranges/range.utility/range.subrange/structured_bindings.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // class std::ranges::subrange;
 
 #include <ranges>
 
 #include <cassert>
 #include "test_macros.h"
 
 constexpr void test_sized_subrange()
 {
     int a[4] = {1,2,3,4};
     auto r = std::ranges::subrange(a, a+4);
     assert(std::ranges::sized_range<decltype(r)>);
     {
         auto [first, last] = r;
         assert(first == a);
         assert(last == a+4);
     }
     {
         auto [first, last] = std::move(r);
         assert(first == a);
         assert(last == a+4);
     }
     {
         auto [first, last] = std::as_const(r);
         assert(first == a);
         assert(last == a+4);
     }
     {
         auto [first, last] = std::move(std::as_const(r));
         assert(first == a);
         assert(last == a+4);
     }
 }
 
 constexpr void test_unsized_subrange()
 {
     int a[4] = {1,2,3,4};
     auto r = std::ranges::subrange(a, std::unreachable_sentinel);
     assert(!std::ranges::sized_range<decltype(r)>);
     {
         auto [first, last] = r;
         assert(first == a);
         ASSERT_SAME_TYPE(decltype(last), std::unreachable_sentinel_t);
     }
     {
         auto [first, last] = std::move(r);
         assert(first == a);
         ASSERT_SAME_TYPE(decltype(last), std::unreachable_sentinel_t);
     }
     {
         auto [first, last] = std::as_const(r);
         assert(first == a);
         ASSERT_SAME_TYPE(decltype(last), std::unreachable_sentinel_t);
     }
     {
         auto [first, last] = std::move(std::as_const(r));
         assert(first == a);
         ASSERT_SAME_TYPE(decltype(last), std::unreachable_sentinel_t);
     }
 }
 
 constexpr void test_copies_not_originals()
 {
     int a[4] = {1,2,3,4};
     {
         auto r = std::ranges::subrange(a, a+4);
         auto&& [first, last] = r;
         ASSERT_SAME_TYPE(decltype(first), int*);
         ASSERT_SAME_TYPE(decltype(last), int*);
         first = a+2;
         last = a+2;
         assert(r.begin() == a);
         assert(r.end() == a+4);
     }
     {
         const auto r = std::ranges::subrange(a, a+4);
         auto&& [first, last] = r;
         ASSERT_SAME_TYPE(decltype(first), int*);
         ASSERT_SAME_TYPE(decltype(last), int*);
         first = a+2;
         last = a+2;
         assert(r.begin() == a);
         assert(r.end() == a+4);
     }
 }
 
 constexpr bool test()
 {
     test_sized_subrange();
     test_unsized_subrange();
     test_copies_not_originals();
     return true;
 }
 
 int main(int, char**)
 {
     test();
     static_assert(test());
 
     return 0;
 }

libcxx/test/std/ranges/range.utility/range.subrange/types.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SUBRANGE_TEST_TYPES_H
-#define SUBRANGE_TEST_TYPES_H
+#ifndef LIBCXX_TEST_STD_RANGES_RANGE_UTILITY_RANGE_SUBRANGE_TYPES_H
+#define LIBCXX_TEST_STD_RANGES_RANGE_UTILITY_RANGE_SUBRANGE_TYPES_H
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
 int globalBuff[8];
 
 struct Empty {};
 

 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<DifferentSentinelWithSizeMember> = true;
 
 using DifferentSentinelWithSizeMemberSubrange = std::ranges::subrange<ForwardIter,
                                                                       DifferentSentinelWithSizeMember::sentinel,
                                                                       std::ranges::subrange_kind::unsized>;
 
-#endif // SUBRANGE_TEST_TYPES_H
+#endif // LIBCXX_TEST_STD_RANGES_RANGE_UTILITY_RANGE_SUBRANGE_TYPES_H