Home | History | Annotate | Download | only in multiset
      1 //===----------------------------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is dual licensed under the MIT and the University of Illinois Open
      6 // Source Licenses. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 // <set>
     11 
     12 // class multiset
     13 
     14 //       iterator find(const key_type& k);
     15 // const_iterator find(const key_type& k) const;
     16 
     17 #include <set>
     18 #include <cassert>
     19 
     20 #include "../../min_allocator.h"
     21 
     22 int main()
     23 {
     24     {
     25         typedef int V;
     26         typedef std::multiset<int> M;
     27         {
     28             typedef M::iterator R;
     29             V ar[] =
     30             {
     31                 5,
     32                 6,
     33                 7,
     34                 8,
     35                 9,
     36                 10,
     37                 11,
     38                 12
     39             };
     40             M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
     41             R r = m.find(5);
     42             assert(r == m.begin());
     43             r = m.find(6);
     44             assert(r == next(m.begin()));
     45             r = m.find(7);
     46             assert(r == next(m.begin(), 2));
     47             r = m.find(8);
     48             assert(r == next(m.begin(), 3));
     49             r = m.find(9);
     50             assert(r == next(m.begin(), 4));
     51             r = m.find(10);
     52             assert(r == next(m.begin(), 5));
     53             r = m.find(11);
     54             assert(r == next(m.begin(), 6));
     55             r = m.find(12);
     56             assert(r == next(m.begin(), 7));
     57             r = m.find(4);
     58             assert(r == next(m.begin(), 8));
     59         }
     60         {
     61             typedef M::const_iterator R;
     62             V ar[] =
     63             {
     64                 5,
     65                 6,
     66                 7,
     67                 8,
     68                 9,
     69                 10,
     70                 11,
     71                 12
     72             };
     73             const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
     74             R r = m.find(5);
     75             assert(r == m.begin());
     76             r = m.find(6);
     77             assert(r == next(m.begin()));
     78             r = m.find(7);
     79             assert(r == next(m.begin(), 2));
     80             r = m.find(8);
     81             assert(r == next(m.begin(), 3));
     82             r = m.find(9);
     83             assert(r == next(m.begin(), 4));
     84             r = m.find(10);
     85             assert(r == next(m.begin(), 5));
     86             r = m.find(11);
     87             assert(r == next(m.begin(), 6));
     88             r = m.find(12);
     89             assert(r == next(m.begin(), 7));
     90             r = m.find(4);
     91             assert(r == next(m.begin(), 8));
     92         }
     93     }
     94 #if __cplusplus >= 201103L
     95     {
     96         typedef int V;
     97         typedef std::multiset<int, std::less<int>, min_allocator<int>> M;
     98         {
     99             typedef M::iterator R;
    100             V ar[] =
    101             {
    102                 5,
    103                 6,
    104                 7,
    105                 8,
    106                 9,
    107                 10,
    108                 11,
    109                 12
    110             };
    111             M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
    112             R r = m.find(5);
    113             assert(r == m.begin());
    114             r = m.find(6);
    115             assert(r == next(m.begin()));
    116             r = m.find(7);
    117             assert(r == next(m.begin(), 2));
    118             r = m.find(8);
    119             assert(r == next(m.begin(), 3));
    120             r = m.find(9);
    121             assert(r == next(m.begin(), 4));
    122             r = m.find(10);
    123             assert(r == next(m.begin(), 5));
    124             r = m.find(11);
    125             assert(r == next(m.begin(), 6));
    126             r = m.find(12);
    127             assert(r == next(m.begin(), 7));
    128             r = m.find(4);
    129             assert(r == next(m.begin(), 8));
    130         }
    131         {
    132             typedef M::const_iterator R;
    133             V ar[] =
    134             {
    135                 5,
    136                 6,
    137                 7,
    138                 8,
    139                 9,
    140                 10,
    141                 11,
    142                 12
    143             };
    144             const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
    145             R r = m.find(5);
    146             assert(r == m.begin());
    147             r = m.find(6);
    148             assert(r == next(m.begin()));
    149             r = m.find(7);
    150             assert(r == next(m.begin(), 2));
    151             r = m.find(8);
    152             assert(r == next(m.begin(), 3));
    153             r = m.find(9);
    154             assert(r == next(m.begin(), 4));
    155             r = m.find(10);
    156             assert(r == next(m.begin(), 5));
    157             r = m.find(11);
    158             assert(r == next(m.begin(), 6));
    159             r = m.find(12);
    160             assert(r == next(m.begin(), 7));
    161             r = m.find(4);
    162             assert(r == next(m.begin(), 8));
    163         }
    164     }
    165 #endif
    166 }
    167