libcxx/test/std/containers/unord/unord.set/local_iterators.compile.fail.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 // <unordered_set>
  10
  11 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
  12 //           class Alloc = allocator<Value>>
  13 // class unordered_set
  14
  15 // local_iterator       begin (size_type n);
  16 // local_iterator       end   (size_type n);
  17 // const_local_iterator begin (size_type n) const;
  18 // const_local_iterator end   (size_type n) const;
  19 // const_local_iterator cbegin(size_type n) const;
  20 // const_local_iterator cend  (size_type n) const;
  21
  22 #include <unordered_set>
  23 #include <cassert>
  24
  25 int main(int, char**)
  26 {
  27     {
  28         typedef std::unordered_set<int> C;
  29         typedef int P;
  30         typedef C::local_iterator I;
  31         P a[] =
  32         {
  33             P(1),
  34             P(2),
  35             P(3),
  36             P(4),
  37             P(1),
  38             P(2)
  39         };
  40         C c(a, a + sizeof(a)/sizeof(a[0]));
  41         assert(c.bucket_count() >= 5);
  42         C::size_type b = c.bucket(0);
  43         I i = c.begin(b);
  44         I j = c.end(b);
  45         assert(std::distance(i, j) == 0);
  46
  47         b = c.bucket(1);
  48         i = c.begin(b);
  49         j = c.end(b);
  50         assert(std::distance(i, j) == 2);
  51         assert(*i == 1);
  52         ++i;
  53         assert(*i == 1);
  54         *i = 2;
  55
  56         b = c.bucket(2);
  57         i = c.begin(b);
  58         j = c.end(b);
  59         assert(std::distance(i, j) == 2);
  60         assert(*i == 2);
  61         ++i;
  62         assert(*i == 2);
  63
  64         b = c.bucket(3);
  65         i = c.begin(b);
  66         j = c.end(b);
  67         assert(std::distance(i, j) == 1);
  68         assert(*i == 3);
  69
  70         b = c.bucket(4);
  71         i = c.begin(b);
  72         j = c.end(b);
  73         assert(std::distance(i, j) == 1);
  74         assert(*i == 4);
  75
  76         b = c.bucket(5);
  77         i = c.begin(b);
  78         j = c.end(b);
  79         assert(std::distance(i, j) == 0);
  80
  81         b = c.bucket(6);
  82         i = c.begin(b);
  83         j = c.end(b);
  84         assert(std::distance(i, j) == 0);
  85     }
  86     {
  87         typedef std::unordered_set<int> C;
  88         typedef int P;
  89         typedef C::const_local_iterator I;
  90         P a[] =
  91         {
  92             P(1),
  93             P(2),
  94             P(3),
  95             P(4),
  96             P(1),
  97             P(2)
  98         };
  99         const C c(a, a + sizeof(a)/sizeof(a[0]));
 100         assert(c.bucket_count() >= 5);
 101         C::size_type b = c.bucket(0);
 102         I i = c.begin(b);
 103         I j = c.end(b);
 104         assert(std::distance(i, j) == 0);
 105
 106         b = c.bucket(1);
 107         i = c.begin(b);
 108         j = c.end(b);
 109         assert(std::distance(i, j) == 2);
 110         assert(*i == 1);
 111         ++i;
 112         assert(*i == 1);
 113
 114         b = c.bucket(2);
 115         i = c.begin(b);
 116         j = c.end(b);
 117         assert(std::distance(i, j) == 2);
 118         assert(*i == 2);
 119         ++i;
 120         assert(*i == 2);
 121
 122         b = c.bucket(3);
 123         i = c.begin(b);
 124         j = c.end(b);
 125         assert(std::distance(i, j) == 1);
 126         assert(*i == 3);
 127
 128         b = c.bucket(4);
 129         i = c.begin(b);
 130         j = c.end(b);
 131         assert(std::distance(i, j) == 1);
 132         assert(*i == 4);
 133
 134         b = c.bucket(5);
 135         i = c.begin(b);
 136         j = c.end(b);
 137         assert(std::distance(i, j) == 0);
 138
 139         b = c.bucket(6);
 140         i = c.begin(b);
 141         j = c.end(b);
 142         assert(std::distance(i, j) == 0);
 143     }
 144     {
 145         typedef std::unordered_set<int> C;
 146         typedef int P;
 147         typedef C::const_local_iterator I;
 148         P a[] =
 149         {
 150             P(1),
 151             P(2),
 152             P(3),
 153             P(4),
 154             P(1),
 155             P(2)
 156         };
 157         C c(a, a + sizeof(a)/sizeof(a[0]));
 158         assert(c.bucket_count() >= 5);
 159         C::size_type b = c.bucket(0);
 160         I i = c.cbegin(b);
 161         I j = c.cend(b);
 162         assert(std::distance(i, j) == 0);
 163
 164         b = c.bucket(1);
 165         i = c.cbegin(b);
 166         j = c.cend(b);
 167         assert(std::distance(i, j) == 2);
 168         assert(*i == 1);
 169         ++i;
 170         assert(*i == 1);
 171
 172         b = c.bucket(2);
 173         i = c.cbegin(b);
 174         j = c.cend(b);
 175         assert(std::distance(i, j) == 2);
 176         assert(*i == 2);
 177         ++i;
 178         assert(*i == 2);
 179
 180         b = c.bucket(3);
 181         i = c.cbegin(b);
 182         j = c.cend(b);
 183         assert(std::distance(i, j) == 1);
 184         assert(*i == 3);
 185
 186         b = c.bucket(4);
 187         i = c.cbegin(b);
 188         j = c.cend(b);
 189         assert(std::distance(i, j) == 1);
 190         assert(*i == 4);
 191
 192         b = c.bucket(5);
 193         i = c.cbegin(b);
 194         j = c.cend(b);
 195         assert(std::distance(i, j) == 0);
 196
 197         b = c.bucket(6);
 198         i = c.cbegin(b);
 199         j = c.cend(b);
 200         assert(std::distance(i, j) == 0);
 201     }
 202     {
 203         typedef std::unordered_set<int> C;
 204         typedef int P;
 205         typedef C::const_local_iterator I;
 206         P a[] =
 207         {
 208             P(1),
 209             P(2),
 210             P(3),
 211             P(4),
 212             P(1),
 213             P(2)
 214         };
 215         const C c(a, a + sizeof(a)/sizeof(a[0]));
 216         assert(c.bucket_count() >= 5);
 217         C::size_type b = c.bucket(0);
 218         I i = c.cbegin(b);
 219         I j = c.cend(b);
 220         assert(std::distance(i, j) == 0);
 221
 222         b = c.bucket(1);
 223         i = c.cbegin(b);
 224         j = c.cend(b);
 225         assert(std::distance(i, j) == 2);
 226         assert(*i == 1);
 227         ++i;
 228         assert(*i == 1);
 229
 230         b = c.bucket(2);
 231         i = c.cbegin(b);
 232         j = c.cend(b);
 233         assert(std::distance(i, j) == 2);
 234         assert(*i == 2);
 235         ++i;
 236         assert(*i == 2);
 237
 238         b = c.bucket(3);
 239         i = c.cbegin(b);
 240         j = c.cend(b);
 241         assert(std::distance(i, j) == 1);
 242         assert(*i == 3);
 243
 244         b = c.bucket(4);
 245         i = c.cbegin(b);
 246         j = c.cend(b);
 247         assert(std::distance(i, j) == 1);
 248         assert(*i == 4);
 249
 250         b = c.bucket(5);
 251         i = c.cbegin(b);
 252         j = c.cend(b);
 253         assert(std::distance(i, j) == 0);
 254
 255         b = c.bucket(6);
 256         i = c.cbegin(b);
 257         j = c.cend(b);
 258         assert(std::distance(i, j) == 0);
 259     }
 260
 261   return 0;
 262 }