libcxx/test/std/containers/associative/multiset/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 multiset
  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::multiset<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::multiset<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::multiset<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::multiset<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 }