1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // XFAIL: c++98, c++03
11
12 // <iterator>
13 // template <class C> constexpr auto begin(C& c) -> decltype(c.begin());
14 // template <class C> constexpr auto begin(const C& c) -> decltype(c.begin());
15 // template <class C> constexpr auto cbegin(const C& c) -> decltype(std::begin(c)); // C++14
16 // template <class C> constexpr auto cend(const C& c) -> decltype(std::end(c)); // C++14
17 // template <class C> constexpr auto end (C& c) -> decltype(c.end());
18 // template <class C> constexpr auto end (const C& c) -> decltype(c.end());
19 // template <class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il);
20 // template <class E> constexpr reverse_iterator<const E*> rend (initializer_list<E> il);
21 //
22 // template <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin()); // C++14
23 // template <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin()); // C++14
24 // template <class C> auto constexpr rend(C& c) -> decltype(c.rend()); // C++14
25 // template <class C> constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14
26 // template <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]); // C++14
27 // template <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]); // C++14
28 // template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14
29 // template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14
30 //
31 // All of these are constexpr in C++17
32
33 #include "test_macros.h"
34
35 #include <iterator>
36 #include <cassert>
37 #include <vector>
38 #include <array>
39 #include <list>
40 #include <initializer_list>
41
42 // std::array is explicitly allowed to be initialized with A a = { init-list };.
43 // Disable the missing braces warning for this reason.
44 #include "disable_missing_braces_warning.h"
45
46 template<typename C>
test_const_container(const C & c,typename C::value_type val)47 void test_const_container( const C & c, typename C::value_type val ) {
48 assert ( std::begin(c) == c.begin());
49 assert (*std::begin(c) == val );
50 assert ( std::begin(c) != c.end());
51 assert ( std::end(c) == c.end());
52 #if TEST_STD_VER > 11
53 assert ( std::cbegin(c) == c.cbegin());
54 assert ( std::cbegin(c) != c.cend());
55 assert ( std::cend(c) == c.cend());
56 assert ( std::rbegin(c) == c.rbegin());
57 assert ( std::rbegin(c) != c.rend());
58 assert ( std::rend(c) == c.rend());
59 assert ( std::crbegin(c) == c.crbegin());
60 assert ( std::crbegin(c) != c.crend());
61 assert ( std::crend(c) == c.crend());
62 #endif
63 }
64
65 template<typename T>
test_const_container(const std::initializer_list<T> & c,T val)66 void test_const_container( const std::initializer_list<T> & c, T val ) {
67 assert ( std::begin(c) == c.begin());
68 assert (*std::begin(c) == val );
69 assert ( std::begin(c) != c.end());
70 assert ( std::end(c) == c.end());
71 #if TEST_STD_VER > 11
72 // initializer_list doesn't have cbegin/cend/rbegin/rend
73 // but std::cbegin(),etc work (b/c they're general fn templates)
74 // assert ( std::cbegin(c) == c.cbegin());
75 // assert ( std::cbegin(c) != c.cend());
76 // assert ( std::cend(c) == c.cend());
77 // assert ( std::rbegin(c) == c.rbegin());
78 // assert ( std::rbegin(c) != c.rend());
79 // assert ( std::rend(c) == c.rend());
80 // assert ( std::crbegin(c) == c.crbegin());
81 // assert ( std::crbegin(c) != c.crend());
82 // assert ( std::crend(c) == c.crend());
83 #endif
84 }
85
86 template<typename C>
test_container(C & c,typename C::value_type val)87 void test_container( C & c, typename C::value_type val ) {
88 assert ( std::begin(c) == c.begin());
89 assert (*std::begin(c) == val );
90 assert ( std::begin(c) != c.end());
91 assert ( std::end(c) == c.end());
92 #if TEST_STD_VER > 11
93 assert ( std::cbegin(c) == c.cbegin());
94 assert ( std::cbegin(c) != c.cend());
95 assert ( std::cend(c) == c.cend());
96 assert ( std::rbegin(c) == c.rbegin());
97 assert ( std::rbegin(c) != c.rend());
98 assert ( std::rend(c) == c.rend());
99 assert ( std::crbegin(c) == c.crbegin());
100 assert ( std::crbegin(c) != c.crend());
101 assert ( std::crend(c) == c.crend());
102 #endif
103 }
104
105 template<typename T>
test_container(std::initializer_list<T> & c,T val)106 void test_container( std::initializer_list<T> & c, T val ) {
107 assert ( std::begin(c) == c.begin());
108 assert (*std::begin(c) == val );
109 assert ( std::begin(c) != c.end());
110 assert ( std::end(c) == c.end());
111 #if TEST_STD_VER > 11
112 // initializer_list doesn't have cbegin/cend/rbegin/rend
113 // assert ( std::cbegin(c) == c.cbegin());
114 // assert ( std::cbegin(c) != c.cend());
115 // assert ( std::cend(c) == c.cend());
116 // assert ( std::rbegin(c) == c.rbegin());
117 // assert ( std::rbegin(c) != c.rend());
118 // assert ( std::rend(c) == c.rend());
119 // assert ( std::crbegin(c) == c.crbegin());
120 // assert ( std::crbegin(c) != c.crend());
121 // assert ( std::crend(c) == c.crend());
122 #endif
123 }
124
125 template<typename T, size_t Sz>
test_const_array(const T (& array)[Sz])126 void test_const_array( const T (&array)[Sz] ) {
127 assert ( std::begin(array) == array );
128 assert (*std::begin(array) == array[0] );
129 assert ( std::begin(array) != std::end(array));
130 assert ( std::end(array) == array + Sz);
131 #if TEST_STD_VER > 11
132 assert ( std::cbegin(array) == array );
133 assert (*std::cbegin(array) == array[0] );
134 assert ( std::cbegin(array) != std::cend(array));
135 assert ( std::cend(array) == array + Sz);
136 #endif
137 }
138
main()139 int main(){
140 std::vector<int> v; v.push_back(1);
141 std::list<int> l; l.push_back(2);
142 std::array<int, 1> a; a[0] = 3;
143 std::initializer_list<int> il = { 4 };
144
145 test_container ( v, 1 );
146 test_container ( l, 2 );
147 test_container ( a, 3 );
148 test_container ( il, 4 );
149
150 test_const_container ( v, 1 );
151 test_const_container ( l, 2 );
152 test_const_container ( a, 3 );
153 test_const_container ( il, 4 );
154
155 static constexpr int arrA [] { 1, 2, 3 };
156 test_const_array ( arrA );
157 #if TEST_STD_VER > 11
158 constexpr const int *b = std::cbegin(arrA);
159 constexpr const int *e = std::cend(arrA);
160 static_assert(e - b == 3, "");
161 #endif
162
163 #if TEST_STD_VER > 14
164 {
165 typedef std::array<int, 5> C;
166 constexpr const C c{0,1,2,3,4};
167
168 static_assert ( c.begin() == std::begin(c), "");
169 static_assert ( c.cbegin() == std::cbegin(c), "");
170 static_assert ( c.end() == std::end(c), "");
171 static_assert ( c.cend() == std::cend(c), "");
172
173 static_assert ( c.rbegin() == std::rbegin(c), "");
174 static_assert ( c.crbegin() == std::crbegin(c), "");
175 static_assert ( c.rend() == std::rend(c), "");
176 static_assert ( c.crend() == std::crend(c), "");
177
178 static_assert ( std::begin(c) != std::end(c), "");
179 static_assert ( std::rbegin(c) != std::rend(c), "");
180 static_assert ( std::cbegin(c) != std::cend(c), "");
181 static_assert ( std::crbegin(c) != std::crend(c), "");
182
183 static_assert ( *c.begin() == 0, "");
184 static_assert ( *c.rbegin() == 4, "");
185
186 static_assert ( *std::begin(c) == 0, "" );
187 static_assert ( *std::cbegin(c) == 0, "" );
188 static_assert ( *std::rbegin(c) == 4, "" );
189 static_assert ( *std::crbegin(c) == 4, "" );
190 }
191
192 {
193 static constexpr const int c[] = {0,1,2,3,4};
194
195 static_assert ( *std::begin(c) == 0, "" );
196 static_assert ( *std::cbegin(c) == 0, "" );
197 static_assert ( *std::rbegin(c) == 4, "" );
198 static_assert ( *std::crbegin(c) == 4, "" );
199 }
200 #endif
201 }
202