libcxx/test/std/containers/associative/map/map.ops/equal_range.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 // <map>
  10
  11 // class map
  12
  13 // pair<iterator,iterator>             equal_range(const key_type& k);
  14 // pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
  15
  16 #include <map>
  17 #include <cassert>
  18
  19 #include "test_macros.h"
  20 #include "min_allocator.h"
  21 #include "private_constructor.h"
  22 #include "is_transparent.h"
  23
  24 int main(int, char**)
  25 {
  26     {
  27     typedef std::pair<const int, double> V;
  28     typedef std::map<int, double> M;
  29     {
  30         typedef std::pair<M::iterator, M::iterator> R;
  31         V ar[] =
  32         {
  33             V(5, 5),
  34             V(7, 6),
  35             V(9, 7),
  36             V(11, 8),
  37             V(13, 9),
  38             V(15, 10),
  39             V(17, 11),
  40             V(19, 12)
  41         };
  42         M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
  43         R r = m.equal_range(5);
  44         assert(r.first == std::next(m.begin(), 0));
  45         assert(r.second == std::next(m.begin(), 1));
  46         r = m.equal_range(7);
  47         assert(r.first == std::next(m.begin(), 1));
  48         assert(r.second == std::next(m.begin(), 2));
  49         r = m.equal_range(9);
  50         assert(r.first == std::next(m.begin(), 2));
  51         assert(r.second == std::next(m.begin(), 3));
  52         r = m.equal_range(11);
  53         assert(r.first == std::next(m.begin(), 3));
  54         assert(r.second == std::next(m.begin(), 4));
  55         r = m.equal_range(13);
  56         assert(r.first == std::next(m.begin(), 4));
  57         assert(r.second == std::next(m.begin(), 5));
  58         r = m.equal_range(15);
  59         assert(r.first == std::next(m.begin(), 5));
  60         assert(r.second == std::next(m.begin(), 6));
  61         r = m.equal_range(17);
  62         assert(r.first == std::next(m.begin(), 6));
  63         assert(r.second == std::next(m.begin(), 7));
  64         r = m.equal_range(19);
  65         assert(r.first == std::next(m.begin(), 7));
  66         assert(r.second == std::next(m.begin(), 8));
  67         r = m.equal_range(4);
  68         assert(r.first == std::next(m.begin(), 0));
  69         assert(r.second == std::next(m.begin(), 0));
  70         r = m.equal_range(6);
  71         assert(r.first == std::next(m.begin(), 1));
  72         assert(r.second == std::next(m.begin(), 1));
  73         r = m.equal_range(8);
  74         assert(r.first == std::next(m.begin(), 2));
  75         assert(r.second == std::next(m.begin(), 2));
  76         r = m.equal_range(10);
  77         assert(r.first == std::next(m.begin(), 3));
  78         assert(r.second == std::next(m.begin(), 3));
  79         r = m.equal_range(12);
  80         assert(r.first == std::next(m.begin(), 4));
  81         assert(r.second == std::next(m.begin(), 4));
  82         r = m.equal_range(14);
  83         assert(r.first == std::next(m.begin(), 5));
  84         assert(r.second == std::next(m.begin(), 5));
  85         r = m.equal_range(16);
  86         assert(r.first == std::next(m.begin(), 6));
  87         assert(r.second == std::next(m.begin(), 6));
  88         r = m.equal_range(18);
  89         assert(r.first == std::next(m.begin(), 7));
  90         assert(r.second == std::next(m.begin(), 7));
  91         r = m.equal_range(20);
  92         assert(r.first == std::next(m.begin(), 8));
  93         assert(r.second == std::next(m.begin(), 8));
  94     }
  95     {
  96         typedef std::pair<M::const_iterator, M::const_iterator> R;
  97         V ar[] =
  98         {
  99             V(5, 5),
 100             V(7, 6),
 101             V(9, 7),
 102             V(11, 8),
 103             V(13, 9),
 104             V(15, 10),
 105             V(17, 11),
 106             V(19, 12)
 107         };
 108         const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 109         R r = m.equal_range(5);
 110         assert(r.first == std::next(m.begin(), 0));
 111         assert(r.second == std::next(m.begin(), 1));
 112         r = m.equal_range(7);
 113         assert(r.first == std::next(m.begin(), 1));
 114         assert(r.second == std::next(m.begin(), 2));
 115         r = m.equal_range(9);
 116         assert(r.first == std::next(m.begin(), 2));
 117         assert(r.second == std::next(m.begin(), 3));
 118         r = m.equal_range(11);
 119         assert(r.first == std::next(m.begin(), 3));
 120         assert(r.second == std::next(m.begin(), 4));
 121         r = m.equal_range(13);
 122         assert(r.first == std::next(m.begin(), 4));
 123         assert(r.second == std::next(m.begin(), 5));
 124         r = m.equal_range(15);
 125         assert(r.first == std::next(m.begin(), 5));
 126         assert(r.second == std::next(m.begin(), 6));
 127         r = m.equal_range(17);
 128         assert(r.first == std::next(m.begin(), 6));
 129         assert(r.second == std::next(m.begin(), 7));
 130         r = m.equal_range(19);
 131         assert(r.first == std::next(m.begin(), 7));
 132         assert(r.second == std::next(m.begin(), 8));
 133         r = m.equal_range(4);
 134         assert(r.first == std::next(m.begin(), 0));
 135         assert(r.second == std::next(m.begin(), 0));
 136         r = m.equal_range(6);
 137         assert(r.first == std::next(m.begin(), 1));
 138         assert(r.second == std::next(m.begin(), 1));
 139         r = m.equal_range(8);
 140         assert(r.first == std::next(m.begin(), 2));
 141         assert(r.second == std::next(m.begin(), 2));
 142         r = m.equal_range(10);
 143         assert(r.first == std::next(m.begin(), 3));
 144         assert(r.second == std::next(m.begin(), 3));
 145         r = m.equal_range(12);
 146         assert(r.first == std::next(m.begin(), 4));
 147         assert(r.second == std::next(m.begin(), 4));
 148         r = m.equal_range(14);
 149         assert(r.first == std::next(m.begin(), 5));
 150         assert(r.second == std::next(m.begin(), 5));
 151         r = m.equal_range(16);
 152         assert(r.first == std::next(m.begin(), 6));
 153         assert(r.second == std::next(m.begin(), 6));
 154         r = m.equal_range(18);
 155         assert(r.first == std::next(m.begin(), 7));
 156         assert(r.second == std::next(m.begin(), 7));
 157         r = m.equal_range(20);
 158         assert(r.first == std::next(m.begin(), 8));
 159         assert(r.second == std::next(m.begin(), 8));
 160     }
 161     }
 162 #if TEST_STD_VER >= 11
 163     {
 164     typedef std::pair<const int, double> V;
 165     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
 166     {
 167         typedef std::pair<M::iterator, M::iterator> R;
 168         V ar[] =
 169         {
 170             V(5, 5),
 171             V(7, 6),
 172             V(9, 7),
 173             V(11, 8),
 174             V(13, 9),
 175             V(15, 10),
 176             V(17, 11),
 177             V(19, 12)
 178         };
 179         M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 180         R r = m.equal_range(5);
 181         assert(r.first == std::next(m.begin(), 0));
 182         assert(r.second == std::next(m.begin(), 1));
 183         r = m.equal_range(7);
 184         assert(r.first == std::next(m.begin(), 1));
 185         assert(r.second == std::next(m.begin(), 2));
 186         r = m.equal_range(9);
 187         assert(r.first == std::next(m.begin(), 2));
 188         assert(r.second == std::next(m.begin(), 3));
 189         r = m.equal_range(11);
 190         assert(r.first == std::next(m.begin(), 3));
 191         assert(r.second == std::next(m.begin(), 4));
 192         r = m.equal_range(13);
 193         assert(r.first == std::next(m.begin(), 4));
 194         assert(r.second == std::next(m.begin(), 5));
 195         r = m.equal_range(15);
 196         assert(r.first == std::next(m.begin(), 5));
 197         assert(r.second == std::next(m.begin(), 6));
 198         r = m.equal_range(17);
 199         assert(r.first == std::next(m.begin(), 6));
 200         assert(r.second == std::next(m.begin(), 7));
 201         r = m.equal_range(19);
 202         assert(r.first == std::next(m.begin(), 7));
 203         assert(r.second == std::next(m.begin(), 8));
 204         r = m.equal_range(4);
 205         assert(r.first == std::next(m.begin(), 0));
 206         assert(r.second == std::next(m.begin(), 0));
 207         r = m.equal_range(6);
 208         assert(r.first == std::next(m.begin(), 1));
 209         assert(r.second == std::next(m.begin(), 1));
 210         r = m.equal_range(8);
 211         assert(r.first == std::next(m.begin(), 2));
 212         assert(r.second == std::next(m.begin(), 2));
 213         r = m.equal_range(10);
 214         assert(r.first == std::next(m.begin(), 3));
 215         assert(r.second == std::next(m.begin(), 3));
 216         r = m.equal_range(12);
 217         assert(r.first == std::next(m.begin(), 4));
 218         assert(r.second == std::next(m.begin(), 4));
 219         r = m.equal_range(14);
 220         assert(r.first == std::next(m.begin(), 5));
 221         assert(r.second == std::next(m.begin(), 5));
 222         r = m.equal_range(16);
 223         assert(r.first == std::next(m.begin(), 6));
 224         assert(r.second == std::next(m.begin(), 6));
 225         r = m.equal_range(18);
 226         assert(r.first == std::next(m.begin(), 7));
 227         assert(r.second == std::next(m.begin(), 7));
 228         r = m.equal_range(20);
 229         assert(r.first == std::next(m.begin(), 8));
 230         assert(r.second == std::next(m.begin(), 8));
 231     }
 232     {
 233         typedef std::pair<M::const_iterator, M::const_iterator> R;
 234         V ar[] =
 235         {
 236             V(5, 5),
 237             V(7, 6),
 238             V(9, 7),
 239             V(11, 8),
 240             V(13, 9),
 241             V(15, 10),
 242             V(17, 11),
 243             V(19, 12)
 244         };
 245         const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 246         R r = m.equal_range(5);
 247         assert(r.first == std::next(m.begin(), 0));
 248         assert(r.second == std::next(m.begin(), 1));
 249         r = m.equal_range(7);
 250         assert(r.first == std::next(m.begin(), 1));
 251         assert(r.second == std::next(m.begin(), 2));
 252         r = m.equal_range(9);
 253         assert(r.first == std::next(m.begin(), 2));
 254         assert(r.second == std::next(m.begin(), 3));
 255         r = m.equal_range(11);
 256         assert(r.first == std::next(m.begin(), 3));
 257         assert(r.second == std::next(m.begin(), 4));
 258         r = m.equal_range(13);
 259         assert(r.first == std::next(m.begin(), 4));
 260         assert(r.second == std::next(m.begin(), 5));
 261         r = m.equal_range(15);
 262         assert(r.first == std::next(m.begin(), 5));
 263         assert(r.second == std::next(m.begin(), 6));
 264         r = m.equal_range(17);
 265         assert(r.first == std::next(m.begin(), 6));
 266         assert(r.second == std::next(m.begin(), 7));
 267         r = m.equal_range(19);
 268         assert(r.first == std::next(m.begin(), 7));
 269         assert(r.second == std::next(m.begin(), 8));
 270         r = m.equal_range(4);
 271         assert(r.first == std::next(m.begin(), 0));
 272         assert(r.second == std::next(m.begin(), 0));
 273         r = m.equal_range(6);
 274         assert(r.first == std::next(m.begin(), 1));
 275         assert(r.second == std::next(m.begin(), 1));
 276         r = m.equal_range(8);
 277         assert(r.first == std::next(m.begin(), 2));
 278         assert(r.second == std::next(m.begin(), 2));
 279         r = m.equal_range(10);
 280         assert(r.first == std::next(m.begin(), 3));
 281         assert(r.second == std::next(m.begin(), 3));
 282         r = m.equal_range(12);
 283         assert(r.first == std::next(m.begin(), 4));
 284         assert(r.second == std::next(m.begin(), 4));
 285         r = m.equal_range(14);
 286         assert(r.first == std::next(m.begin(), 5));
 287         assert(r.second == std::next(m.begin(), 5));
 288         r = m.equal_range(16);
 289         assert(r.first == std::next(m.begin(), 6));
 290         assert(r.second == std::next(m.begin(), 6));
 291         r = m.equal_range(18);
 292         assert(r.first == std::next(m.begin(), 7));
 293         assert(r.second == std::next(m.begin(), 7));
 294         r = m.equal_range(20);
 295         assert(r.first == std::next(m.begin(), 8));
 296         assert(r.second == std::next(m.begin(), 8));
 297     }
 298     }
 299 #endif
 300 #if TEST_STD_VER > 11
 301     {
 302     typedef std::pair<const int, double> V;
 303     typedef std::map<int, double, std::less<>> M;
 304     typedef std::pair<M::iterator, M::iterator> R;
 305
 306     V ar[] =
 307     {
 308         V(5, 5),
 309         V(7, 6),
 310         V(9, 7),
 311         V(11, 8),
 312         V(13, 9),
 313         V(15, 10),
 314         V(17, 11),
 315         V(19, 12)
 316     };
 317     M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 318     R r = m.equal_range(5);
 319     assert(r.first == std::next(m.begin(), 0));
 320     assert(r.second == std::next(m.begin(), 1));
 321     r = m.equal_range(7);
 322     assert(r.first == std::next(m.begin(), 1));
 323     assert(r.second == std::next(m.begin(), 2));
 324     r = m.equal_range(9);
 325     assert(r.first == std::next(m.begin(), 2));
 326     assert(r.second == std::next(m.begin(), 3));
 327     r = m.equal_range(11);
 328     assert(r.first == std::next(m.begin(), 3));
 329     assert(r.second == std::next(m.begin(), 4));
 330     r = m.equal_range(13);
 331     assert(r.first == std::next(m.begin(), 4));
 332     assert(r.second == std::next(m.begin(), 5));
 333     r = m.equal_range(15);
 334     assert(r.first == std::next(m.begin(), 5));
 335     assert(r.second == std::next(m.begin(), 6));
 336     r = m.equal_range(17);
 337     assert(r.first == std::next(m.begin(), 6));
 338     assert(r.second == std::next(m.begin(), 7));
 339     r = m.equal_range(19);
 340     assert(r.first == std::next(m.begin(), 7));
 341     assert(r.second == std::next(m.begin(), 8));
 342     r = m.equal_range(4);
 343     assert(r.first == std::next(m.begin(), 0));
 344     assert(r.second == std::next(m.begin(), 0));
 345     r = m.equal_range(6);
 346     assert(r.first == std::next(m.begin(), 1));
 347     assert(r.second == std::next(m.begin(), 1));
 348     r = m.equal_range(8);
 349     assert(r.first == std::next(m.begin(), 2));
 350     assert(r.second == std::next(m.begin(), 2));
 351     r = m.equal_range(10);
 352     assert(r.first == std::next(m.begin(), 3));
 353     assert(r.second == std::next(m.begin(), 3));
 354     r = m.equal_range(12);
 355     assert(r.first == std::next(m.begin(), 4));
 356     assert(r.second == std::next(m.begin(), 4));
 357     r = m.equal_range(14);
 358     assert(r.first == std::next(m.begin(), 5));
 359     assert(r.second == std::next(m.begin(), 5));
 360     r = m.equal_range(16);
 361     assert(r.first == std::next(m.begin(), 6));
 362     assert(r.second == std::next(m.begin(), 6));
 363     r = m.equal_range(18);
 364     assert(r.first == std::next(m.begin(), 7));
 365     assert(r.second == std::next(m.begin(), 7));
 366     r = m.equal_range(20);
 367     assert(r.first == std::next(m.begin(), 8));
 368     assert(r.second == std::next(m.begin(), 8));
 369
 370     r = m.equal_range(C2Int(5));
 371     assert(r.first == std::next(m.begin(), 0));
 372     assert(r.second == std::next(m.begin(), 1));
 373     r = m.equal_range(C2Int(7));
 374     assert(r.first == std::next(m.begin(), 1));
 375     assert(r.second == std::next(m.begin(), 2));
 376     r = m.equal_range(C2Int(9));
 377     assert(r.first == std::next(m.begin(), 2));
 378     assert(r.second == std::next(m.begin(), 3));
 379     r = m.equal_range(C2Int(11));
 380     assert(r.first == std::next(m.begin(), 3));
 381     assert(r.second == std::next(m.begin(), 4));
 382     r = m.equal_range(C2Int(13));
 383     assert(r.first == std::next(m.begin(), 4));
 384     assert(r.second == std::next(m.begin(), 5));
 385     r = m.equal_range(C2Int(15));
 386     assert(r.first == std::next(m.begin(), 5));
 387     assert(r.second == std::next(m.begin(), 6));
 388     r = m.equal_range(C2Int(17));
 389     assert(r.first == std::next(m.begin(), 6));
 390     assert(r.second == std::next(m.begin(), 7));
 391     r = m.equal_range(C2Int(19));
 392     assert(r.first == std::next(m.begin(), 7));
 393     assert(r.second == std::next(m.begin(), 8));
 394     r = m.equal_range(C2Int(4));
 395     assert(r.first == std::next(m.begin(), 0));
 396     assert(r.second == std::next(m.begin(), 0));
 397     r = m.equal_range(C2Int(6));
 398     assert(r.first == std::next(m.begin(), 1));
 399     assert(r.second == std::next(m.begin(), 1));
 400     r = m.equal_range(C2Int(8));
 401     assert(r.first == std::next(m.begin(), 2));
 402     assert(r.second == std::next(m.begin(), 2));
 403     r = m.equal_range(C2Int(10));
 404     assert(r.first == std::next(m.begin(), 3));
 405     assert(r.second == std::next(m.begin(), 3));
 406     r = m.equal_range(C2Int(12));
 407     assert(r.first == std::next(m.begin(), 4));
 408     assert(r.second == std::next(m.begin(), 4));
 409     r = m.equal_range(C2Int(14));
 410     assert(r.first == std::next(m.begin(), 5));
 411     assert(r.second == std::next(m.begin(), 5));
 412     r = m.equal_range(C2Int(16));
 413     assert(r.first == std::next(m.begin(), 6));
 414     assert(r.second == std::next(m.begin(), 6));
 415     r = m.equal_range(C2Int(18));
 416     assert(r.first == std::next(m.begin(), 7));
 417     assert(r.second == std::next(m.begin(), 7));
 418     r = m.equal_range(C2Int(20));
 419     assert(r.first == std::next(m.begin(), 8));
 420     assert(r.second == std::next(m.begin(), 8));
 421     }
 422     {
 423     typedef PrivateConstructor PC;
 424     typedef std::map<PC, double, std::less<>> M;
 425     typedef std::pair<M::iterator, M::iterator> R;
 426
 427     M m;
 428     m [ PC::make(5)  ] = 5;
 429     m [ PC::make(7)  ] = 6;
 430     m [ PC::make(9)  ] = 7;
 431     m [ PC::make(11) ] = 8;
 432     m [ PC::make(13) ] = 9;
 433     m [ PC::make(15) ] = 10;
 434     m [ PC::make(17) ] = 11;
 435     m [ PC::make(19) ] = 12;
 436
 437     R r = m.equal_range(5);
 438     assert(r.first == std::next(m.begin(), 0));
 439     assert(r.second == std::next(m.begin(), 1));
 440     r = m.equal_range(7);
 441     assert(r.first == std::next(m.begin(), 1));
 442     assert(r.second == std::next(m.begin(), 2));
 443     r = m.equal_range(9);
 444     assert(r.first == std::next(m.begin(), 2));
 445     assert(r.second == std::next(m.begin(), 3));
 446     r = m.equal_range(11);
 447     assert(r.first == std::next(m.begin(), 3));
 448     assert(r.second == std::next(m.begin(), 4));
 449     r = m.equal_range(13);
 450     assert(r.first == std::next(m.begin(), 4));
 451     assert(r.second == std::next(m.begin(), 5));
 452     r = m.equal_range(15);
 453     assert(r.first == std::next(m.begin(), 5));
 454     assert(r.second == std::next(m.begin(), 6));
 455     r = m.equal_range(17);
 456     assert(r.first == std::next(m.begin(), 6));
 457     assert(r.second == std::next(m.begin(), 7));
 458     r = m.equal_range(19);
 459     assert(r.first == std::next(m.begin(), 7));
 460     assert(r.second == std::next(m.begin(), 8));
 461     r = m.equal_range(4);
 462     assert(r.first == std::next(m.begin(), 0));
 463     assert(r.second == std::next(m.begin(), 0));
 464     r = m.equal_range(6);
 465     assert(r.first == std::next(m.begin(), 1));
 466     assert(r.second == std::next(m.begin(), 1));
 467     r = m.equal_range(8);
 468     assert(r.first == std::next(m.begin(), 2));
 469     assert(r.second == std::next(m.begin(), 2));
 470     r = m.equal_range(10);
 471     assert(r.first == std::next(m.begin(), 3));
 472     assert(r.second == std::next(m.begin(), 3));
 473     r = m.equal_range(12);
 474     assert(r.first == std::next(m.begin(), 4));
 475     assert(r.second == std::next(m.begin(), 4));
 476     r = m.equal_range(14);
 477     assert(r.first == std::next(m.begin(), 5));
 478     assert(r.second == std::next(m.begin(), 5));
 479     r = m.equal_range(16);
 480     assert(r.first == std::next(m.begin(), 6));
 481     assert(r.second == std::next(m.begin(), 6));
 482     r = m.equal_range(18);
 483     assert(r.first == std::next(m.begin(), 7));
 484     assert(r.second == std::next(m.begin(), 7));
 485     r = m.equal_range(20);
 486     assert(r.first == std::next(m.begin(), 8));
 487     assert(r.second == std::next(m.begin(), 8));
 488     }
 489 #endif
 490
 491   return 0;
 492 }