libcxx/test/std/containers/associative/set/iterator.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // <set>
  10
  11 // class set
  12
  13 //       iterator begin();
  14 // const_iterator begin() const;
  15 //       iterator end();
  16 // const_iterator end()   const;
  17 //
  18 //       reverse_iterator rbegin();
  19 // const_reverse_iterator rbegin() const;
  20 //       reverse_iterator rend();
  21 // const_reverse_iterator rend()   const;
  22 //
  23 // const_iterator         cbegin()  const;
  24 // const_iterator         cend()    const;
  25 // const_reverse_iterator crbegin() const;
  26 // const_reverse_iterator crend()   const;
  27
  28 #include <set>
  29 #include <cassert>
  30 #include <cstddef>
  31
  32 #include "test_macros.h"
  33 #include "min_allocator.h"
  34
  35 int main(int, char**)
  36 {
  37     {
  38         typedef int V;
  39         V ar[] =
  40         {
  41             1,
  42             1,
  43             1,
  44             2,
  45             2,
  46             2,
  47             3,
  48             3,
  49             3,
  50             4,
  51             4,
  52             4,
  53             5,
  54             5,
  55             5,
  56             6,
  57             6,
  58             6,
  59             7,
  60             7,
  61             7,
  62             8,
  63             8,
  64             8
  65         };
  66         std::set<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
  67         assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
  68         assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
  69         std::set<int>::iterator i;
  70         i = m.begin();
  71         std::set<int>::const_iterator k = i;
  72         assert(i == k);
  73         for (int j = 1; j <= static_cast<int>(m.size()); ++j, ++i)
  74             assert(*i == j);
  75         assert(i == m.end());
  76         for (int j = static_cast<int>(m.size()); j >= 1; --j) {
  77             --i;
  78             assert(*i == j);
  79         }
  80         assert(i == m.begin());
  81     }
  82     {
  83         typedef int V;
  84         V ar[] =
  85         {
  86             1,
  87             1,
  88             1,
  89             2,
  90             2,
  91             2,
  92             3,
  93             3,
  94             3,
  95             4,
  96             4,
  97             4,
  98             5,
  99             5,
 100             5,
 101             6,
 102             6,
 103             6,
 104             7,
 105             7,
 106             7,
 107             8,
 108             8,
 109             8
 110         };
 111         const std::set<int> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 112         assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
 113         assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
 114         assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
 115         assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
 116         std::set<int>::const_iterator i;
 117         i = m.begin();
 118         for (int j = 1; j <= static_cast<int>(m.size()); ++j, ++i)
 119             assert(*i == j);
 120         assert(i == m.end());
 121         for (int j = static_cast<int>(m.size()); j >= 1; --j) {
 122             --i;
 123             assert(*i == j);
 124         }
 125         assert(i == m.begin());
 126     }
 127 #if TEST_STD_VER >= 11
 128     {
 129         typedef int V;
 130         V ar[] =
 131         {
 132             1,
 133             1,
 134             1,
 135             2,
 136             2,
 137             2,
 138             3,
 139             3,
 140             3,
 141             4,
 142             4,
 143             4,
 144             5,
 145             5,
 146             5,
 147             6,
 148             6,
 149             6,
 150             7,
 151             7,
 152             7,
 153             8,
 154             8,
 155             8
 156         };
 157         std::set<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 158         assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
 159         assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
 160         std::set<int, std::less<int>, min_allocator<int>>::iterator i;
 161         i = m.begin();
 162         std::set<int, std::less<int>, min_allocator<int>>::const_iterator k = i;
 163         assert(i == k);
 164         for (int j = 1; j <= static_cast<int>(m.size()); ++j, ++i)
 165             assert(*i == j);
 166         assert(i == m.end());
 167         for (int j = static_cast<int>(m.size()); j >= 1; --j) {
 168             --i;
 169             assert(*i == j);
 170         }
 171         assert(i == m.begin());
 172     }
 173     {
 174         typedef int V;
 175         V ar[] =
 176         {
 177             1,
 178             1,
 179             1,
 180             2,
 181             2,
 182             2,
 183             3,
 184             3,
 185             3,
 186             4,
 187             4,
 188             4,
 189             5,
 190             5,
 191             5,
 192             6,
 193             6,
 194             6,
 195             7,
 196             7,
 197             7,
 198             8,
 199             8,
 200             8
 201         };
 202         const std::set<int, std::less<int>, min_allocator<int>> m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 203         assert(static_cast<std::size_t>(std::distance(m.begin(), m.end())) == m.size());
 204         assert(static_cast<std::size_t>(std::distance(m.cbegin(), m.cend())) == m.size());
 205         assert(static_cast<std::size_t>(std::distance(m.rbegin(), m.rend())) == m.size());
 206         assert(static_cast<std::size_t>(std::distance(m.crbegin(), m.crend())) == m.size());
 207         std::set<int, std::less<int>, min_allocator<int>>::const_iterator i;
 208         i = m.begin();
 209         for (int j = 1; j <= static_cast<int>(m.size()); ++j, ++i)
 210             assert(*i == j);
 211         assert(i == m.end());
 212         for (int j = static_cast<int>(m.size()); j >= 1; --j) {
 213             --i;
 214             assert(*i == j);
 215         }
 216         assert(i == m.begin());
 217     }
 218 #endif
 219 #if TEST_STD_VER > 11
 220     { // N3644 testing
 221         typedef std::set<int> C;
 222         C::iterator ii1{}, ii2{};
 223         C::iterator ii4 = ii1;
 224         C::const_iterator cii{};
 225         assert ( ii1 == ii2 );
 226         assert ( ii1 == ii4 );
 227
 228         assert (!(ii1 != ii2 ));
 229
 230         assert ( (ii1 == cii ));
 231         assert ( (cii == ii1 ));
 232         assert (!(ii1 != cii ));
 233         assert (!(cii != ii1 ));
 234     }
 235 #endif
 236
 237   return 0;
 238 }