libstdc++-v3/testsuite/23_containers/multimap/operations/2.cc

   1 // Copyright (C) 2015-2020 Free Software Foundation, Inc.
   2 //
   3 // This file is part of the GNU ISO C++ Library.  This library is free
   4 // software; you can redistribute it and/or modify it under the
   5 // terms of the GNU General Public License as published by the
   6 // Free Software Foundation; either version 3, or (at your option)
   7 // any later version.
   8
   9 // This library is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13
  14 // You should have received a copy of the GNU General Public License along
  15 // with this library; see the file COPYING3.  If not see
  16 // <http://www.gnu.org/licenses/>.
  17
  18 // { dg-do run { target c++14 } }
  19
  20 #include <map>
  21 #include <testsuite_hooks.h>
  22
  23 struct Cmp
  24 {
  25   typedef void is_transparent;
  26
  27   bool operator()(int i, long l) const { return i < l; }
  28   bool operator()(long l, int i) const { return l < i; }
  29   bool operator()(int i, int j) const { ++count; return i < j; }
  30
  31   static int count;
  32 };
  33
  34 int Cmp::count = 0;
  35
  36 using test_type = std::multimap<int, char, Cmp>;
  37
  38 test_type x{ { 1, '2' }, { 3, '4' }, { 3, '5' } };
  39 const test_type& cx = x;
  40
  41 void
  42 test01()
  43 {
  44   Cmp::count = 0;
  45
  46   auto it = x.find(1L);
  47   VERIFY( it != x.end() && it->second == '2' );
  48   it = x.find(2L);
  49   VERIFY( it == x.end() );
  50
  51   auto cit = cx.find(3L);
  52   VERIFY( cit != cx.end() && cit->second == '4' );
  53   cit = cx.find(2L);
  54   VERIFY( cit == cx.end() );
  55
  56   VERIFY( Cmp::count == 0 );
  57
  58   static_assert(std::is_same<decltype(it), test_type::iterator>::value,
  59       "find returns iterator");
  60   static_assert(std::is_same<decltype(cit), test_type::const_iterator>::value,
  61       "const find returns const_iterator");
  62 }
  63
  64 void
  65 test02()
  66 {
  67   Cmp::count = 0;
  68
  69   auto n = x.count(1L);
  70   VERIFY( n == 1 );
  71   n = x.count(2L);
  72   VERIFY( n == 0 );
  73
  74   auto cn = cx.count(3L);
  75   VERIFY( cn == 2 );
  76   cn = cx.count(2L);
  77   VERIFY( cn == 0 );
  78
  79   VERIFY( Cmp::count == 0 );
  80 }
  81
  82 void
  83 test03()
  84 {
  85   Cmp::count = 0;
  86
  87   auto it = x.lower_bound(1L);
  88   VERIFY( it != x.end() && it->second == '2' );
  89   it = x.lower_bound(2L);
  90   VERIFY( it != x.end() && it->second == '4' );
  91
  92   auto cit = cx.lower_bound(1L);
  93   VERIFY( cit != cx.end() && cit->second == '2' );
  94   cit = cx.lower_bound(2L);
  95   VERIFY( cit != cx.end() && cit->second == '4' );
  96
  97   VERIFY( Cmp::count == 0 );
  98
  99   static_assert(std::is_same<decltype(it), test_type::iterator>::value,
 100       "lower_bound returns iterator");
 101   static_assert(std::is_same<decltype(cit), test_type::const_iterator>::value,
 102       "const lower_bound returns const_iterator");
 103 }
 104
 105 void
 106 test04()
 107 {
 108   Cmp::count = 0;
 109
 110   auto it = x.upper_bound(1L);
 111   VERIFY( it != x.end() && it->second == '4' );
 112   it = x.upper_bound(3L);
 113   VERIFY( it == x.end() );
 114
 115   auto cit = cx.upper_bound(1L);
 116   VERIFY( cit != cx.end() && cit->second == '4' );
 117   cit = cx.upper_bound(3L);
 118   VERIFY( cit == cx.end() );
 119
 120   VERIFY( Cmp::count == 0 );
 121
 122   static_assert(std::is_same<decltype(it), test_type::iterator>::value,
 123       "upper_bound returns iterator");
 124   static_assert(std::is_same<decltype(cit), test_type::const_iterator>::value,
 125       "const upper_bound returns const_iterator");
 126 }
 127
 128 void
 129 test05()
 130 {
 131   Cmp::count = 0;
 132
 133   auto it = x.equal_range(1L);
 134   VERIFY( it.first != it.second && it.first->second == '2' );
 135   it = x.equal_range(2L);
 136   VERIFY( it.first == it.second && it.first != x.end() );
 137
 138   auto cit = cx.equal_range(3L);
 139   VERIFY( cit.first != cit.second && cit.first->second == '4' );
 140   VERIFY( std::distance(cit.first, cit.second) == 2 );
 141   cit = cx.equal_range(2L);
 142   VERIFY( cit.first == cit.second && cit.first != cx.end() );
 143
 144   VERIFY( Cmp::count == 0 );
 145
 146   using pair = std::pair<test_type::iterator, test_type::iterator>;
 147   static_assert(std::is_same<decltype(it), pair>::value,
 148       "equal_range returns pair<iterator, iterator>");
 149   using cpair = std::pair<test_type::const_iterator, test_type::const_iterator>;
 150   static_assert(std::is_same<decltype(cit), cpair>::value,
 151       "const equal_range returns pair<const_iterator, const_iterator>");
 152 }
 153
 154
 155 int
 156 main()
 157 {
 158   test01();
 159   test02();
 160   test03();
 161   test04();
 162   test05();
 163 }