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