1 // Copyright (C) 2020 Free Software Foundation, Inc.
2 //
3 // This file is part of the GNU ISO C++ Library. This library is free
4 // software; you can redistribute it and/or modify it under the
5 // terms of the GNU General Public License as published by the
6 // Free Software Foundation; either version 3, or (at your option)
7 // any later version.
8
9 // This library is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU General Public License for more details.
13
14 // You should have received a copy of the GNU General Public License along
15 // with this library; see the file COPYING3. If not see
16 // <http://www.gnu.org/licenses/>.
17
18 // { dg-options "-std=gnu++2a" }
19 // { dg-do run { target c++2a } }
20
21 #include <algorithm>
22 #include <ranges>
23 #include <testsuite_hooks.h>
24 #include <testsuite_iterators.h>
25
26 using __gnu_test::test_range;
27 using __gnu_test::random_access_iterator_wrapper;
28
29 namespace ranges = std::ranges;
30 namespace views = std::ranges::views;
31
32 void
test01()33 test01()
34 {
35 int x[] = {1,2,3,4,5};
36 auto is_odd = [] (int i) { return i%2==1; };
37 auto v = x | views::transform(is_odd);
38 VERIFY( ranges::equal(v, (int[]){1,0,1,0,1}) );
39 using R = decltype(v);
40 static_assert(std::same_as<bool, decltype(*ranges::begin(v))>);
41 static_assert(ranges::view<R>);
42 static_assert(ranges::sized_range<R>);
43 static_assert(ranges::random_access_range<R>);
44 }
45
46 struct X
47 {
48 int i,j;
49 };
50
51 void
test02()52 test02()
53 {
54 X x[] = {{1,2},{3,4},{5,6},{7,8},{9,10}};
55 test_range<X, random_access_iterator_wrapper> rx(x);
56 auto v = rx | views::transform(&X::i);
57 VERIFY( ranges::size(v) == 5 );
58 VERIFY( ranges::distance(v.begin(), v.end()) == 5 );
59 VERIFY( ranges::equal(v, (int[]){1,3,5,7,9}) );
60 VERIFY( ranges::equal(v | views::reverse, (int[]){9,7,5,3,1}) );
61 using R = decltype(v);
62 static_assert(std::same_as<int&, decltype(*ranges::begin(v))>);
63 static_assert(std::same_as<int, std::iter_value_t<ranges::iterator_t<R>>>);
64 static_assert(ranges::view<R>);
65 static_assert(ranges::sized_range<R>);
66 static_assert(!ranges::common_range<R>);
67 static_assert(ranges::random_access_range<R>);
68 }
69
70 void
test03()71 test03()
72 {
73 auto id = [] (int i) { return i; };
74 auto v = views::iota(0) | (views::filter(id)
75 | views::transform(id)
76 | views::take(5));
77 VERIFY( ranges::equal(v, (int[]){1,2,3,4,5}) );
78 }
79
80 void
test04()81 test04()
82 {
83 // LWG 3301
84 {
85 auto f = [] (int x) { return x; };
86 int x[] = {1,2,3,4,5};
87 auto v = x | views::transform(f);
88 auto i = v.begin();
89 using Cat = decltype(i)::iterator_category;
90 static_assert(std::same_as<Cat, std::input_iterator_tag>);
91 }
92
93 {
94 auto f = [] (int &x) -> int& { return x; };
95 int x[] = {1,2,3,4,5};
96 auto v = x | views::transform(f);
97 auto i = v.begin();
98 using Cat = decltype(i)::iterator_category;
99 static_assert(std::derived_from<Cat, std::forward_iterator_tag>);
100 }
101 }
102
103 void
test05()104 test05()
105 {
106 int x[] = {1,2,3,4,5};
107 auto i = std::counted_iterator(x, 5);
108 auto r = ranges::subrange{i, std::default_sentinel};
109 auto v = r | views::transform(std::negate{});
110
111 // Verify that _Iterator<false> is implicitly convertible to _Iterator<true>.
112 static_assert(!std::same_as<decltype(ranges::begin(v)),
113 decltype(ranges::cbegin(v))>);
114 auto a = ranges::cbegin(v);
115 a = ranges::begin(v);
116
117 // Verify that _Sentinel<false> is implicitly convertible to _Sentinel<true>.
118 static_assert(!ranges::common_range<decltype(v)>);
119 static_assert(!std::same_as<decltype(ranges::end(v)),
120 decltype(ranges::cend(v))>);
121 auto b = ranges::cend(v);
122 b = ranges::end(v);
123 }
124
125 struct Y
126 {
127 using Iter = __gnu_test::forward_iterator_wrapper<Y>;
128
operator -(Iter l,Iter r)129 friend auto operator-(Iter l, Iter r) { return l.ptr - r.ptr; }
130 };
131
132 void
test06()133 test06()
134 {
135 using ranges::next;
136 using ranges::begin;
137
138 // LWG 3483
139 Y y[3];
140 __gnu_test::test_forward_range<Y> r(y);
141 auto v = views::transform(r, std::identity{});
142 auto b = begin(v);
143 static_assert( !ranges::random_access_range<decltype(r)> );
144 static_assert( std::sized_sentinel_for<decltype(b), decltype(b)> );
145 VERIFY( (next(b, 1) - b) == 1 );
146 const auto v_const = v;
147 auto b_const = begin(v_const);
148 VERIFY( (next(b_const, 2) - b_const) == 2 );
149 }
150
151 int
main()152 main()
153 {
154 test01();
155 test02();
156 test03();
157 test04();
158 test05();
159 test06();
160 }
161