libcxx/test/std/containers/associative/map/map.ops/find.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 //       iterator find(const key_type& k);
  14 // const_iterator find(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 M::iterator R;
  31         V ar[] =
  32         {
  33             V(5, 5),
  34             V(6, 6),
  35             V(7, 7),
  36             V(8, 8),
  37             V(9, 9),
  38             V(10, 10),
  39             V(11, 11),
  40             V(12, 12)
  41         };
  42         M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
  43         R r = m.find(5);
  44         assert(r == m.begin());
  45         r = m.find(6);
  46         assert(r == std::next(m.begin()));
  47         r = m.find(7);
  48         assert(r == std::next(m.begin(), 2));
  49         r = m.find(8);
  50         assert(r == std::next(m.begin(), 3));
  51         r = m.find(9);
  52         assert(r == std::next(m.begin(), 4));
  53         r = m.find(10);
  54         assert(r == std::next(m.begin(), 5));
  55         r = m.find(11);
  56         assert(r == std::next(m.begin(), 6));
  57         r = m.find(12);
  58         assert(r == std::next(m.begin(), 7));
  59         r = m.find(4);
  60         assert(r == std::next(m.begin(), 8));
  61     }
  62     {
  63         typedef M::const_iterator R;
  64         V ar[] =
  65         {
  66             V(5, 5),
  67             V(6, 6),
  68             V(7, 7),
  69             V(8, 8),
  70             V(9, 9),
  71             V(10, 10),
  72             V(11, 11),
  73             V(12, 12)
  74         };
  75         const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
  76         R r = m.find(5);
  77         assert(r == m.begin());
  78         r = m.find(6);
  79         assert(r == std::next(m.begin()));
  80         r = m.find(7);
  81         assert(r == std::next(m.begin(), 2));
  82         r = m.find(8);
  83         assert(r == std::next(m.begin(), 3));
  84         r = m.find(9);
  85         assert(r == std::next(m.begin(), 4));
  86         r = m.find(10);
  87         assert(r == std::next(m.begin(), 5));
  88         r = m.find(11);
  89         assert(r == std::next(m.begin(), 6));
  90         r = m.find(12);
  91         assert(r == std::next(m.begin(), 7));
  92         r = m.find(4);
  93         assert(r == std::next(m.begin(), 8));
  94     }
  95     }
  96 #if TEST_STD_VER >= 11
  97     {
  98     typedef std::pair<const int, double> V;
  99     typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
 100     {
 101         typedef M::iterator R;
 102         V ar[] =
 103         {
 104             V(5, 5),
 105             V(6, 6),
 106             V(7, 7),
 107             V(8, 8),
 108             V(9, 9),
 109             V(10, 10),
 110             V(11, 11),
 111             V(12, 12)
 112         };
 113         M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 114         R r = m.find(5);
 115         assert(r == m.begin());
 116         r = m.find(6);
 117         assert(r == std::next(m.begin()));
 118         r = m.find(7);
 119         assert(r == std::next(m.begin(), 2));
 120         r = m.find(8);
 121         assert(r == std::next(m.begin(), 3));
 122         r = m.find(9);
 123         assert(r == std::next(m.begin(), 4));
 124         r = m.find(10);
 125         assert(r == std::next(m.begin(), 5));
 126         r = m.find(11);
 127         assert(r == std::next(m.begin(), 6));
 128         r = m.find(12);
 129         assert(r == std::next(m.begin(), 7));
 130         r = m.find(4);
 131         assert(r == std::next(m.begin(), 8));
 132     }
 133     {
 134         typedef M::const_iterator R;
 135         V ar[] =
 136         {
 137             V(5, 5),
 138             V(6, 6),
 139             V(7, 7),
 140             V(8, 8),
 141             V(9, 9),
 142             V(10, 10),
 143             V(11, 11),
 144             V(12, 12)
 145         };
 146         const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 147         R r = m.find(5);
 148         assert(r == m.begin());
 149         r = m.find(6);
 150         assert(r == std::next(m.begin()));
 151         r = m.find(7);
 152         assert(r == std::next(m.begin(), 2));
 153         r = m.find(8);
 154         assert(r == std::next(m.begin(), 3));
 155         r = m.find(9);
 156         assert(r == std::next(m.begin(), 4));
 157         r = m.find(10);
 158         assert(r == std::next(m.begin(), 5));
 159         r = m.find(11);
 160         assert(r == std::next(m.begin(), 6));
 161         r = m.find(12);
 162         assert(r == std::next(m.begin(), 7));
 163         r = m.find(4);
 164         assert(r == std::next(m.begin(), 8));
 165     }
 166     }
 167 #endif
 168 #if TEST_STD_VER > 11
 169     {
 170     typedef std::pair<const int, double> V;
 171     typedef std::map<int, double, std::less<>> M;
 172     typedef M::iterator R;
 173
 174     V ar[] =
 175     {
 176         V(5, 5),
 177         V(6, 6),
 178         V(7, 7),
 179         V(8, 8),
 180         V(9, 9),
 181         V(10, 10),
 182         V(11, 11),
 183         V(12, 12)
 184     };
 185     M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
 186     R r = m.find(5);
 187     assert(r == m.begin());
 188     r = m.find(6);
 189     assert(r == std::next(m.begin()));
 190     r = m.find(7);
 191     assert(r == std::next(m.begin(), 2));
 192     r = m.find(8);
 193     assert(r == std::next(m.begin(), 3));
 194     r = m.find(9);
 195     assert(r == std::next(m.begin(), 4));
 196     r = m.find(10);
 197     assert(r == std::next(m.begin(), 5));
 198     r = m.find(11);
 199     assert(r == std::next(m.begin(), 6));
 200     r = m.find(12);
 201     assert(r == std::next(m.begin(), 7));
 202     r = m.find(4);
 203     assert(r == std::next(m.begin(), 8));
 204
 205     r = m.find(C2Int(5));
 206     assert(r == m.begin());
 207     r = m.find(C2Int(6));
 208     assert(r == std::next(m.begin()));
 209     r = m.find(C2Int(7));
 210     assert(r == std::next(m.begin(), 2));
 211     r = m.find(C2Int(8));
 212     assert(r == std::next(m.begin(), 3));
 213     r = m.find(C2Int(9));
 214     assert(r == std::next(m.begin(), 4));
 215     r = m.find(C2Int(10));
 216     assert(r == std::next(m.begin(), 5));
 217     r = m.find(C2Int(11));
 218     assert(r == std::next(m.begin(), 6));
 219     r = m.find(C2Int(12));
 220     assert(r == std::next(m.begin(), 7));
 221     r = m.find(C2Int(4));
 222     assert(r == std::next(m.begin(), 8));
 223     }
 224
 225     {
 226     typedef PrivateConstructor PC;
 227     typedef std::map<PC, double, std::less<>> M;
 228     typedef M::iterator R;
 229
 230     M m;
 231     m [ PC::make(5)  ] = 5;
 232     m [ PC::make(6)  ] = 6;
 233     m [ PC::make(7)  ] = 7;
 234     m [ PC::make(8)  ] = 8;
 235     m [ PC::make(9)  ] = 9;
 236     m [ PC::make(10) ] = 10;
 237     m [ PC::make(11) ] = 11;
 238     m [ PC::make(12) ] = 12;
 239
 240     R r = m.find(5);
 241     assert(r == m.begin());
 242     r = m.find(6);
 243     assert(r == std::next(m.begin()));
 244     r = m.find(7);
 245     assert(r == std::next(m.begin(), 2));
 246     r = m.find(8);
 247     assert(r == std::next(m.begin(), 3));
 248     r = m.find(9);
 249     assert(r == std::next(m.begin(), 4));
 250     r = m.find(10);
 251     assert(r == std::next(m.begin(), 5));
 252     r = m.find(11);
 253     assert(r == std::next(m.begin(), 6));
 254     r = m.find(12);
 255     assert(r == std::next(m.begin(), 7));
 256     r = m.find(4);
 257     assert(r == std::next(m.begin(), 8));
 258     }
 259 #endif
 260
 261   return 0;
 262 }