get rid of auto

anonymouspc · anonymouspc · commit 52a93dcef5fe · 2025-12-11T13:47:18.000+08:00
diff --git a/libcxx/test/std/ranges/range.adaptors/range.chunk/adaptor.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.chunk/adaptor.pass.cpp
@@ -23,8 +23,8 @@
 #include "types.h"
 
 constexpr bool test() {
-  std::array array = {1, 2, 3, 4, 5, 6, 7, 8};
-  auto view        = array | std::views::all;
+  std::array<int,8> array = {1, 2, 3, 4, 5, 6, 7, 8};
+  std::ranges::ref_view<std::array<int,8>> view = array | std::views::all;
 
   // Test `views::chunk(view, n)`
   {
@@ -39,7 +39,7 @@ constexpr bool test() {
   // Test `views::chunk(n)(range)`
   {
     static_assert(noexcept(std::views::chunk(2)));
-    auto adaptor = std::views::chunk(3);
+    /*__pipable*/ auto adaptor = std::views::chunk(3);
     std::same_as<std::ranges::chunk_view<std::ranges::ref_view<std::array<int, 8>>>> decltype(auto) chunked =
         adaptor(view);
     assert(std::ranges::equal(*chunked.begin(), std::array{1, 2, 3}));
@@ -60,7 +60,7 @@ constexpr bool test() {
 
   // Test `views::chunk | adaptor`
   {
-    auto adaptors                          = std::views::chunk(5) | std::views::join;
+    /*__pipable*/ auto adaptors = std::views::chunk(5) | std::views::join;
     std::ranges::input_range auto rejoined = view | adaptors;
     assert(std::ranges::equal(rejoined, view));
     std::ranges::input_range auto const_rejoined = std::as_const(view) | adaptors;
diff --git a/libcxx/test/std/ranges/range.adaptors/range.chunk/base.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.chunk/base.pass.cpp
@@ -22,9 +22,9 @@
 #include "test_range.h"
 
 constexpr bool test() {
-  std::array array   = {1, 2, 3, 4, 5, 6, 7, 8};
-  auto chunked       = array | std::views::chunk(3);
-  auto const_chunked = std::as_const(array) | std::views::chunk(4);
+  std::array<int,8> array   = {1, 2, 3, 4, 5, 6, 7, 8};
+  std::ranges::chunk_view<std::ranges::ref_view<std::array<int,8>>> chunked = array | std::views::chunk(3);
+  std::ranges::chunk_view<std::ranges::ref_view<const std::array<int,8>>> const_chunked = std::as_const(array) | std::views::chunk(4);
 
   // Test `chunk_view.base()`
   {
diff --git a/libcxx/test/std/ranges/range.adaptors/range.chunk/begin.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.chunk/begin.pass.cpp
@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <ranges>
 #include <vector>
 
@@ -27,13 +28,13 @@
 
 constexpr bool test() {
   std::vector<int> vector = {1, 2, 3, 4, 5, 6, 7, 8};
-  auto chunked            = vector | std::views::chunk(3);
-  auto const_chunked      = std::as_const(vector) | std::views::chunk(3);
-  auto input_chunked      = input_span<int>(vector.data(), 8) | std::views::chunk(3);
+  std::ranges::chunk_view<std::ranges::ref_view<std::vector<int>>> chunked = vector | std::views::chunk(3);
+  std::ranges::chunk_view<std::ranges::ref_view<const std::vector<int>>> const_chunked      = std::as_const(vector) | std::views::chunk(3);
+  std::ranges::chunk_view<input_span<int>> input_chunked = input_span<int>(vector.data(), 8) | std::views::chunk(3);
 
   // Test `chunk_view.begin()` when V models only input_range
   {
-    auto it = input_chunked.begin();
+    /*chunk_view::__outer_iterator*/ std::input_iterator auto it = input_chunked.begin();
     assert(std::ranges::equal(*it, std::vector{1, 2, 3}));
     assert(std::ranges::equal(*++it, std::vector{4, 5, 6}));
     assert(std::ranges::equal(*++it, std::vector{7, 8}));
@@ -42,12 +43,12 @@ constexpr bool test() {
 
   // Test `chunk_view.begin()` when V models forward_range
   {
-    auto it = chunked.begin();
+    /*chunk_view::__iterator<false>*/ std::forward_iterator auto it = chunked.begin();
     assert(std::ranges::equal(*it, std::vector{1, 2, 3}));
     assert(std::ranges::equal(*++it, std::vector{4, 5, 6}));
     assert(std::ranges::equal(*++it, std::vector{7, 8}));
     assert(++it == chunked.end());
-    auto const_it = const_chunked.begin();
+    /*chunk_view::__iterator<true>*/ std::forward_iterator auto const_it = const_chunked.begin();
     assert(std::ranges::equal(*const_it, std::vector{1, 2, 3}));
     assert(std::ranges::equal(*++const_it, std::vector{4, 5, 6}));
     assert(std::ranges::equal(*++const_it, std::vector{7, 8}));
diff --git a/libcxx/test/std/ranges/range.adaptors/range.chunk/ctad.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.chunk/ctad.compile.pass.cpp
@@ -38,14 +38,18 @@ void test_ctad() {
   range r;
   borrowed_range br;
 
-  static_assert(std::same_as<decltype(std::ranges::chunk_view(v, 0)), std::ranges::chunk_view<view>>);
-  static_assert(std::same_as<decltype(std::ranges::chunk_view(std::move(v), 0)), std::ranges::chunk_view<view>>);
-  static_assert(
-      std::same_as< decltype(std::ranges::chunk_view(r, 0)), std::ranges::chunk_view<std::ranges::ref_view<range>>>);
+  // clang-format off
+  static_assert(std::same_as<decltype(std::ranges::chunk_view(v, 0)), 
+                                      std::ranges::chunk_view<view>>);
+  static_assert(std::same_as<decltype(std::ranges::chunk_view(std::move(v), 0)), 
+                                      std::ranges::chunk_view<view>>);
+  static_assert(std::same_as<decltype(std::ranges::chunk_view(r, 0)), 
+                                      std::ranges::chunk_view<std::ranges::ref_view<range>>>);
   static_assert(std::same_as<decltype(std::ranges::chunk_view(std::move(r), 0)),
-                             std::ranges::chunk_view<std::ranges::owning_view<range>>>);
+                                      std::ranges::chunk_view<std::ranges::owning_view<range>>>);
   static_assert(std::same_as<decltype(std::ranges::chunk_view(br, 0)),
-                             std::ranges::chunk_view<std::ranges::ref_view<borrowed_range>>>);
+                                      std::ranges::chunk_view<std::ranges::ref_view<borrowed_range>>>);
   static_assert(std::same_as<decltype(std::ranges::chunk_view(std::move(br), 0)),
-                             std::ranges::chunk_view<std::ranges::owning_view<borrowed_range>>>);
+                                      std::ranges::chunk_view<std::ranges::owning_view<borrowed_range>>>);
+  // clang-format on
 }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.chunk/end.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.chunk/end.pass.cpp
@@ -29,9 +29,9 @@
 
 constexpr bool test() {
   std::vector<int> vector = {1, 2, 3, 4, 5, 6, 7, 8};
-  auto chunked            = vector | std::views::chunk(3);
-  auto const_chunked      = std::as_const(vector) | std::views::chunk(3);
-  auto input_chunked      = input_span<int>(vector.data(), 8) | std::views::chunk(3);
+  std::ranges::chunk_view<std::ranges::ref_view<std::vector<int>>> chunked = vector | std::views::chunk(3);
+  std::ranges::chunk_view<std::ranges::ref_view<const std::vector<int>>> const_chunked      = std::as_const(vector) | std::views::chunk(3);
+  std::ranges::chunk_view<input_span<int>> input_chunked = input_span<int>(vector.data(), 8) | std::views::chunk(3);
 
   // Test `chunk_view.end()` when V models only input_range
   {
@@ -41,12 +41,12 @@ constexpr bool test() {
 
   // Test `chunk_view.end()` when V models forward_range
   {
-    std::random_access_iterator auto it = chunked.end();
+    /*chunk_view::__iterator<false>*/ std::forward_iterator auto it = chunked.end();
     assert(std::ranges::equal(*--it, std::vector{7, 8}));
     assert(std::ranges::equal(*--it, std::vector{4, 5, 6}));
     assert(std::ranges::equal(*--it, std::vector{1, 2, 3}));
     assert(it == chunked.begin());
-    std::random_access_iterator auto const_it = const_chunked.end();
+    /*chunk_view::__iterator<true>*/ std::forward_iterator auto const_it = const_chunked.end();
     assert(std::ranges::equal(*--const_it, std::vector{7, 8}));
     assert(std::ranges::equal(*--const_it, std::vector{4, 5, 6}));
     assert(std::ranges::equal(*--const_it, std::vector{1, 2, 3}));
diff --git a/libcxx/test/std/ranges/range.adaptors/range.chunk/general.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.chunk/general.pass.cpp
@@ -20,7 +20,7 @@
 #include "test_range.h"
 
 constexpr bool test() {
-  auto str = std::string_view("Cheese the chicken chunk by chunk on truck by truck");
+  std::string_view str = "Cheese with chicken chunk by chunk on truck with my trick";
   // clang-format off
   auto str2 = str 
             | std::views::chunk(4)
diff --git a/libcxx/test/std/ranges/range.adaptors/range.chunk/range.chunk.iter/compare.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.chunk/range.chunk.iter/compare.pass.cpp
@@ -43,12 +43,12 @@
 
 constexpr bool test() {
   std::vector<int> vector = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
-  auto chunked            = vector | std::views::chunk(3);
-  auto input_chunked      = input_span<int>(vector) | std::views::chunk(3);
+  std::ranges::chunk_view<std::ranges::ref_view<std::vector<int>>> chunked = vector | std::views::chunk(3);
+  std::ranges::chunk_view<input_span<int>> input_chunked = input_span<int>(vector) | std::views::chunk(3);
 
   // Test `friend constexpr bool opreator==(const outer_iterator& x, default_sentinel_t)`
   {
-    auto it = input_chunked.begin();
+    /*chunk_view::__outer_iterator*/ std::input_iterator auto it = input_chunked.begin();
     std::ranges::advance(it, 4);
     assert(it == std::default_sentinel);
   }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.chunk/range.chunk.iter/decrement.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.chunk/range.chunk.iter/decrement.pass.cpp
@@ -19,31 +19,32 @@
 
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <ranges>
 #include <vector>
 
 #include "test_range.h"
 
 constexpr bool test() {
   std::vector<int> vector = {1, 2, 3, 4, 5, 6, 7, 8};
-  auto chunked            = vector | std::views::chunk(2);
+  std::ranges::chunk_view<std::ranges::ref_view<std::vector<int>>> chunked            = vector | std::views::chunk(2);
 
   // Test `constexpr iterator& operator--();`
   {
-    auto it = chunked.end();
+    /*chunk_view::__outer_iterator*/ std::bidirectional_iterator auto it = chunked.end();
     assert(std::ranges::equal(*--it, std::vector{7, 8}));
   }
 
   // Test `constexpr iterator operator--(int)`
   {
-    auto it = chunked.end();
+    /*chunk_view::__outer_iterator*/ std::bidirectional_iterator auto it = chunked.end();
     it--;
     assert(std::ranges::equal(*it, std::vector{7, 8}));
   }
 
   // Test `constexpr iterator& operator-=(difference_type)`
   {
-    auto it = chunked.end();
+    /*chunk_view::__iterator*/ std::random_access_iterator auto it = chunked.end();
     it -= 3;
     assert(std::ranges::equal(*it, std::vector{3, 4}));
   }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.chunk/range.chunk.iter/deref.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.chunk/range.chunk.iter/deref.pass.cpp
@@ -31,8 +31,8 @@
 
 constexpr bool test() {
   std::vector<int> vector = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
-  auto chunked            = vector | std::views::chunk(3);
-  auto input_chunked      = input_span<int>(vector) | std::views::chunk(3);
+  std::ranges::chunk_view<std::ranges::ref_view<std::vector<int>>> chunked = vector | std::views::chunk(3);
+  std::ranges::chunk_view<input_span<int>> input_chunked      = input_span<int>(vector) | std::views::chunk(3);
 
   // Test `constexpr value_type outer_iterator::operator*() const`
   {
@@ -41,28 +41,29 @@ constexpr bool test() {
 
   // Test `constexpr inner_iterator outer_iterator::value_type::begin() const noexcept`
   {
-    auto inner = *input_chunked.begin();
+    /*chunk_view::__outer_iterator::value_type*/ std::ranges::input_range auto inner = *input_chunked.begin();
     assert(*inner.begin() == *vector.begin());
     static_assert(noexcept(inner.begin()));
   }
 
   // Test `constexpr default_sentinel_t outer_iterator::value_type::end() const noexcept`
   {
-    auto inner                                                     = *input_chunked.begin();
+    /*chunk_view::__outer_iterator::value_type*/ std::ranges::input_range auto inner = *input_chunked.begin();
     [[maybe_unused]] std::same_as<std::default_sentinel_t> auto it = inner.end();
     static_assert(noexcept((inner.end())));
   }
 
-  // Test `constexpr range_reference_v<V> inner_iterator::operator*() const`
+  // Test `constexpr value_type iterator::operator*() const`
   {
-    std::same_as<int&> decltype(auto) v = *(*chunked.begin()).begin();
+    /*chunk_view::__inner_iterator*/ std::input_iterator auto it = (*input_chunked.begin()).begin();
+    std::same_as<int> decltype(auto) v = *it;
     assert(v == 1);
   }
 
-  // Test `constexpr value_type iterator::operator*() const`
+  // Test `constexpr range_reference_v<V> inner_iterator::operator*() const`
   {
-    auto inner = *input_chunked.begin();
-    assert(*inner.begin() == *vector.begin());
+    std::same_as<int&> decltype(auto) v = *(*chunked.begin()).begin();
+    assert(v == 1);
   }
 
   return true;
diff --git a/libcxx/test/std/ranges/range.adaptors/range.chunk/range.chunk.iter/increment.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.chunk/range.chunk.iter/increment.pass.cpp
@@ -24,6 +24,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <ranges>
 #include <vector>
 
@@ -32,53 +33,53 @@
 
 constexpr bool test() {
   std::vector<int> vector = {1, 2, 3, 4, 5, 6, 7, 8};
-  auto chunked            = vector | std::views::chunk(2);
-  auto input_chunked      = input_span<int>(vector) | std::views::chunk(2);
+  std::ranges::chunk_view<std::ranges::ref_view<std::vector<int>>> chunked            = vector | std::views::chunk(2);
+  std::ranges::chunk_view<input_span<int>> input_chunked = input_span<int>(vector) | std::views::chunk(2);
 
   // Test `constexpr outer_iterator& operator++();`
   {
-    auto it = input_chunked.begin();
+    /*chunk_view::__outer_iterator*/ std::input_iterator auto it = input_chunked.begin();
     assert(std::ranges::equal(*++it, std::vector{3, 4}));
   }
 
   // Test `constexpr void operator++(int);`
   {
-    auto it = input_chunked.begin();
+    /*chunk_view::__outer_iterator*/ std::input_iterator auto it = input_chunked.begin();
     static_assert(std::same_as<decltype(it++), void>);
     it++;
     assert(std::ranges::equal(*it, std::vector{3, 4}));
   }
 
   // Test `constexpr inner_iterator& operator++();`
   {
-    auto it = (*input_chunked.begin()).begin();
+    /*chunk_view::__inner_iterator*/ std::input_iterator auto it = (*input_chunked.begin()).begin();
     assert(*++it == 2);
   }
 
   // Test `constexpr inner_iterator& operator++();`
   {
-    auto it = (*input_chunked.begin()).begin();
+    /*chunk_view::__inner_iterator*/ std::input_iterator auto it = (*input_chunked.begin()).begin();
     static_assert(std::same_as<decltype(it++), void>);
     it++;
     assert(*it == 2);
   }
 
   // Test `constexpr iterator& operator++();`
   {
-    auto it = chunked.begin();
+    /*chunk_view::__iterator*/ std::forward_iterator auto it = chunked.begin();
     assert(std::ranges::equal(*++it, std::vector{3, 4}));
   }
 
   // Test `constexpr iterator operator++(int)`
   {
-    auto it = chunked.begin();
+    /*chunk_view::__iterator*/ std::forward_iterator auto it = chunked.begin();
     it++;
     assert(std::ranges::equal(*it, std::vector{3, 4}));
   }
 
   // Test `constexpr iterator& operator+=(difference_type)`
   {
-    auto it = chunked.begin();
+    /*chunk_view::__iterator*/ std::random_access_iterator auto it = chunked.begin();
     it += 3;
     assert(std::ranges::equal(*it, std::vector{7, 8}));
   }

Original file line number	Diff line number	Diff line change
`@@ -43,12 +43,12 @@`
`43`	`43`
`44`	`44`	`constexpr bool test() {`
`45`	`45`	`std::vector<int> vector = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};`
`46`		`- auto chunked = vector \| std::views::chunk(3);`
`47`		`- auto input_chunked = input_span<int>(vector) \| std::views::chunk(3);`
	`46`	`+ std::ranges::chunk_view<std::ranges::ref_view<std::vector<int>>> chunked = vector \| std::views::chunk(3);`
	`47`	`+ std::ranges::chunk_view<input_span<int>> input_chunked = input_span<int>(vector) \| std::views::chunk(3);`
`48`	`48`
`49`	`49`	// Test `friend constexpr bool opreator==(const outer_iterator& x, default_sentinel_t)`
`50`	`50`	`{`
`51`		`- auto it = input_chunked.begin();`
	`51`	`+ /chunk_view::__outer_iterator/ std::input_iterator auto it = input_chunked.begin();`
`52`	`52`	`std::ranges::advance(it, 4);`
`53`	`53`	`assert(it == std::default_sentinel);`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,31 +19,32 @@`
`19`	`19`
`20`	`20`	`#include <algorithm>`
`21`	`21`	`#include <cassert>`
	`22`	`+#include <iterator>`
`22`	`23`	`#include <ranges>`
`23`	`24`	`#include <vector>`
`24`	`25`
`25`	`26`	`#include "test_range.h"`
`26`	`27`
`27`	`28`	`constexpr bool test() {`
`28`	`29`	`std::vector<int> vector = {1, 2, 3, 4, 5, 6, 7, 8};`
`29`		`- auto chunked = vector \| std::views::chunk(2);`
	`30`	`+ std::ranges::chunk_view<std::ranges::ref_view<std::vector<int>>> chunked = vector \| std::views::chunk(2);`
`30`	`31`
`31`	`32`	// Test `constexpr iterator& operator--();`
`32`	`33`	`{`
`33`		`- auto it = chunked.end();`
	`34`	`+ /chunk_view::__outer_iterator/ std::bidirectional_iterator auto it = chunked.end();`
`34`	`35`	`assert(std::ranges::equal(*--it, std::vector{7, 8}));`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	// Test `constexpr iterator operator--(int)`
`38`	`39`	`{`
`39`		`- auto it = chunked.end();`
	`40`	`+ /chunk_view::__outer_iterator/ std::bidirectional_iterator auto it = chunked.end();`
`40`	`41`	`it--;`
`41`	`42`	`assert(std::ranges::equal(*it, std::vector{7, 8}));`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	// Test `constexpr iterator& operator-=(difference_type)`
`45`	`46`	`{`
`46`		`- auto it = chunked.end();`
	`47`	`+ /chunk_view::__iterator/ std::random_access_iterator auto it = chunked.end();`
`47`	`48`	`it -= 3;`
`48`	`49`	`assert(std::ranges::equal(*it, std::vector{3, 4}));`
`49`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,8 +31,8 @@`
`31`	`31`
`32`	`32`	`constexpr bool test() {`
`33`	`33`	`std::vector<int> vector = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};`
`34`		`- auto chunked = vector \| std::views::chunk(3);`
`35`		`- auto input_chunked = input_span<int>(vector) \| std::views::chunk(3);`
	`34`	`+ std::ranges::chunk_view<std::ranges::ref_view<std::vector<int>>> chunked = vector \| std::views::chunk(3);`
	`35`	`+ std::ranges::chunk_view<input_span<int>> input_chunked = input_span<int>(vector) \| std::views::chunk(3);`
`36`	`36`
`37`	`37`	// Test `constexpr value_type outer_iterator::operator*() const`
`38`	`38`	`{`
`@@ -41,28 +41,29 @@ constexpr bool test() {`
`41`	`41`
`42`	`42`	// Test `constexpr inner_iterator outer_iterator::value_type::begin() const noexcept`
`43`	`43`	`{`
`44`		`- auto inner = *input_chunked.begin();`
	`44`	`+ /chunk_view::__outer_iterator::value_type/ std::ranges::input_range auto inner = *input_chunked.begin();`
`45`	`45`	`assert(inner.begin() == vector.begin());`
`46`	`46`	`static_assert(noexcept(inner.begin()));`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	// Test `constexpr default_sentinel_t outer_iterator::value_type::end() const noexcept`
`50`	`50`	`{`
`51`		`- auto inner = *input_chunked.begin();`
	`51`	`+ /chunk_view::__outer_iterator::value_type/ std::ranges::input_range auto inner = *input_chunked.begin();`
`52`	`52`	`[[maybe_unused]] std::same_as<std::default_sentinel_t> auto it = inner.end();`
`53`	`53`	`static_assert(noexcept((inner.end())));`
`54`	`54`	`}`
`55`	`55`
`56`		- // Test `constexpr range_reference_v<V> inner_iterator::operator*() const`
	`56`	+ // Test `constexpr value_type iterator::operator*() const`
`57`	`57`	`{`
`58`		`- std::same_as<int&> decltype(auto) v = (chunked.begin()).begin();`
	`58`	`+ /chunk_view::__inner_iterator/ std::input_iterator auto it = (*input_chunked.begin()).begin();`
	`59`	`+ std::same_as<int> decltype(auto) v = *it;`
`59`	`60`	`assert(v == 1);`
`60`	`61`	`}`
`61`	`62`
`62`		- // Test `constexpr value_type iterator::operator*() const`
	`63`	+ // Test `constexpr range_reference_v<V> inner_iterator::operator*() const`
`63`	`64`	`{`
`64`		`- auto inner = *input_chunked.begin();`
`65`		`- assert(inner.begin() == vector.begin());`
	`65`	`+ std::same_as<int&> decltype(auto) v = (chunked.begin()).begin();`
	`66`	`+ assert(v == 1);`
`66`	`67`	`}`
`67`	`68`
`68`	`69`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@`
`24`	`24`
`25`	`25`	`#include <algorithm>`
`26`	`26`	`#include <cassert>`
	`27`	`+#include <iterator>`
`27`	`28`	`#include <ranges>`
`28`	`29`	`#include <vector>`
`29`	`30`
`@@ -32,53 +33,53 @@`
`32`	`33`
`33`	`34`	`constexpr bool test() {`
`34`	`35`	`std::vector<int> vector = {1, 2, 3, 4, 5, 6, 7, 8};`
`35`		`- auto chunked = vector \| std::views::chunk(2);`
`36`		`- auto input_chunked = input_span<int>(vector) \| std::views::chunk(2);`
	`36`	`+ std::ranges::chunk_view<std::ranges::ref_view<std::vector<int>>> chunked = vector \| std::views::chunk(2);`
	`37`	`+ std::ranges::chunk_view<input_span<int>> input_chunked = input_span<int>(vector) \| std::views::chunk(2);`
`37`	`38`
`38`	`39`	// Test `constexpr outer_iterator& operator++();`
`39`	`40`	`{`
`40`		`- auto it = input_chunked.begin();`
	`41`	`+ /chunk_view::__outer_iterator/ std::input_iterator auto it = input_chunked.begin();`
`41`	`42`	`assert(std::ranges::equal(*++it, std::vector{3, 4}));`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	// Test `constexpr void operator++(int);`
`45`	`46`	`{`
`46`		`- auto it = input_chunked.begin();`
	`47`	`+ /chunk_view::__outer_iterator/ std::input_iterator auto it = input_chunked.begin();`
`47`	`48`	`static_assert(std::same_as<decltype(it++), void>);`
`48`	`49`	`it++;`
`49`	`50`	`assert(std::ranges::equal(*it, std::vector{3, 4}));`
`50`	`51`	`}`
`51`	`52`
`52`	`53`	// Test `constexpr inner_iterator& operator++();`
`53`	`54`	`{`
`54`		`- auto it = (*input_chunked.begin()).begin();`
	`55`	`+ /chunk_view::__inner_iterator/ std::input_iterator auto it = (*input_chunked.begin()).begin();`
`55`	`56`	`assert(*++it == 2);`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	// Test `constexpr inner_iterator& operator++();`
`59`	`60`	`{`
`60`		`- auto it = (*input_chunked.begin()).begin();`
	`61`	`+ /chunk_view::__inner_iterator/ std::input_iterator auto it = (*input_chunked.begin()).begin();`
`61`	`62`	`static_assert(std::same_as<decltype(it++), void>);`
`62`	`63`	`it++;`
`63`	`64`	`assert(*it == 2);`
`64`	`65`	`}`
`65`	`66`
`66`	`67`	// Test `constexpr iterator& operator++();`
`67`	`68`	`{`
`68`		`- auto it = chunked.begin();`
	`69`	`+ /chunk_view::__iterator/ std::forward_iterator auto it = chunked.begin();`
`69`	`70`	`assert(std::ranges::equal(*++it, std::vector{3, 4}));`
`70`	`71`	`}`
`71`	`72`
`72`	`73`	// Test `constexpr iterator operator++(int)`
`73`	`74`	`{`
`74`		`- auto it = chunked.begin();`
	`75`	`+ /chunk_view::__iterator/ std::forward_iterator auto it = chunked.begin();`
`75`	`76`	`it++;`
`76`	`77`	`assert(std::ranges::equal(*it, std::vector{3, 4}));`
`77`	`78`	`}`
`78`	`79`
`79`	`80`	// Test `constexpr iterator& operator+=(difference_type)`
`80`	`81`	`{`
`81`		`- auto it = chunked.begin();`
	`82`	`+ /chunk_view::__iterator/ std::random_access_iterator auto it = chunked.begin();`
`82`	`83`	`it += 3;`
`83`	`84`	`assert(std::ranges::equal(*it, std::vector{7, 8}));`
`84`	`85`	`}`