test/std/iterators/iterator.range/begin-end.pass.cpp

   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++03, c++98
  11
  12 // <iterator>
  13 // template <class C> auto begin(C& c) -> decltype(c.begin());
  14 // template <class C> auto begin(const C& c) -> decltype(c.begin());
  15 // template <class C> auto end(C& c) -> decltype(c.end());
  16 // template <class C> auto end(const C& c) -> decltype(c.end());
  17 // template <class E> reverse_iterator<const E*> rbegin(initializer_list<E> il);
  18 // template <class E> reverse_iterator<const E*> rend(initializer_list<E> il);
  19
  20 #include "test_macros.h"
  21
  22 #include <iterator>
  23 #include <cassert>
  24 #include <vector>
  25 #include <array>
  26 #include <list>
  27 #include <initializer_list>
  28
  29 template<typename C>
  30 void test_const_container( const C & c, typename C::value_type val ) {
  31     assert ( std::begin(c)   == c.begin());
  32     assert (*std::begin(c)   ==  val );
  33     assert ( std::begin(c)   != c.end());
  34     assert ( std::end(c)     == c.end());
  35 #if TEST_STD_VER > 11
  36     assert ( std::cbegin(c)  == c.cbegin());
  37     assert ( std::cbegin(c)  != c.cend());
  38     assert ( std::cend(c)    == c.cend());
  39     assert ( std::rbegin(c)  == c.rbegin());
  40     assert ( std::rbegin(c)  != c.rend());
  41     assert ( std::rend(c)    == c.rend());
  42     assert ( std::crbegin(c) == c.crbegin());
  43     assert ( std::crbegin(c) != c.crend());
  44     assert ( std::crend(c)   == c.crend());
  45 #endif
  46     }
  47
  48 template<typename T>
  49 void test_const_container( const std::initializer_list<T> & c, T val ) {
  50     assert ( std::begin(c)   == c.begin());
  51     assert (*std::begin(c)   ==  val );
  52     assert ( std::begin(c)   != c.end());
  53     assert ( std::end(c)     == c.end());
  54 #if TEST_STD_VER > 11
  55 //  initializer_list doesn't have cbegin/cend/rbegin/rend
  56 //  but std::cbegin(),etc work (b/c they're general fn templates)
  57 //     assert ( std::cbegin(c)  == c.cbegin());
  58 //     assert ( std::cbegin(c)  != c.cend());
  59 //     assert ( std::cend(c)    == c.cend());
  60 //     assert ( std::rbegin(c)  == c.rbegin());
  61 //     assert ( std::rbegin(c)  != c.rend());
  62 //     assert ( std::rend(c)    == c.rend());
  63 //     assert ( std::crbegin(c) == c.crbegin());
  64 //     assert ( std::crbegin(c) != c.crend());
  65 //     assert ( std::crend(c)   == c.crend());
  66 #endif
  67     }
  68
  69 template<typename C>
  70 void test_container( C & c, typename C::value_type val ) {
  71     assert ( std::begin(c)   == c.begin());
  72     assert (*std::begin(c)   ==  val );
  73     assert ( std::begin(c)   != c.end());
  74     assert ( std::end(c)     == c.end());
  75 #if TEST_STD_VER > 11
  76     assert ( std::cbegin(c)  == c.cbegin());
  77     assert ( std::cbegin(c)  != c.cend());
  78     assert ( std::cend(c)    == c.cend());
  79     assert ( std::rbegin(c)  == c.rbegin());
  80     assert ( std::rbegin(c)  != c.rend());
  81     assert ( std::rend(c)    == c.rend());
  82     assert ( std::crbegin(c) == c.crbegin());
  83     assert ( std::crbegin(c) != c.crend());
  84     assert ( std::crend(c)   == c.crend());
  85 #endif
  86     }
  87
  88 template<typename T>
  89 void test_container( std::initializer_list<T> & c, T val ) {
  90     assert ( std::begin(c)   == c.begin());
  91     assert (*std::begin(c)   ==  val );
  92     assert ( std::begin(c)   != c.end());
  93     assert ( std::end(c)     == c.end());
  94 #if TEST_STD_VER > 11
  95 //  initializer_list doesn't have cbegin/cend/rbegin/rend
  96 //     assert ( std::cbegin(c)  == c.cbegin());
  97 //     assert ( std::cbegin(c)  != c.cend());
  98 //     assert ( std::cend(c)    == c.cend());
  99 //     assert ( std::rbegin(c)  == c.rbegin());
 100 //     assert ( std::rbegin(c)  != c.rend());
 101 //     assert ( std::rend(c)    == c.rend());
 102 //     assert ( std::crbegin(c) == c.crbegin());
 103 //     assert ( std::crbegin(c) != c.crend());
 104 //     assert ( std::crend(c)   == c.crend());
 105 #endif
 106     }
 107
 108 template<typename T, size_t Sz>
 109 void test_const_array( const T (&array)[Sz] ) {
 110     assert ( std::begin(array)  == array );
 111     assert (*std::begin(array)  ==  array[0] );
 112     assert ( std::begin(array)  != std::end(array));
 113     assert ( std::end(array)    == array + Sz);
 114 #if TEST_STD_VER > 11
 115     assert ( std::cbegin(array) == array );
 116     assert (*std::cbegin(array) == array[0] );
 117     assert ( std::cbegin(array) != std::cend(array));
 118     assert ( std::cend(array)   == array + Sz);
 119 #endif
 120     }
 121
 122 int main(){
 123     std::vector<int> v; v.push_back(1);
 124     std::list<int> l;   l.push_back(2);
 125     std::array<int, 1> a; a[0] = 3;
 126     std::initializer_list<int> il = { 4 };
 127
 128     test_container ( v, 1 );
 129     test_container ( l, 2 );
 130     test_container ( a, 3 );
 131     test_container ( il, 4 );
 132
 133     test_const_container ( v, 1 );
 134     test_const_container ( l, 2 );
 135     test_const_container ( a, 3 );
 136     test_const_container ( il, 4 );
 137
 138     static constexpr int arrA [] { 1, 2, 3 };
 139     test_const_array ( arrA );
 140 #if TEST_STD_VER > 11
 141     constexpr const int *b = std::cbegin(arrA);
 142     constexpr const int *e = std::cend(arrA);
 143     static_assert(e - b == 3, "");
 144 #endif
 145 }