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

   1 // Copyright (C) 2015-2023 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::map<int, char, Cmp>;
  37
  38 test_type x{ { 1, '2' }, { 3, '4' } };
  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 == 1 );
  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(1L);
 139   VERIFY( cit.first != cit.second && cit.first->second == '2' );
 140   cit = cx.equal_range(2L);
 141   VERIFY( cit.first == cit.second && cit.first != cx.end() );
 142
 143   VERIFY( Cmp::count == 0 );
 144
 145   using pair = std::pair<test_type::iterator, test_type::iterator>;
 146   static_assert(std::is_same<decltype(it), pair>::value,
 147       "equal_range returns pair<iterator, iterator>");
 148   using cpair = std::pair<test_type::const_iterator, test_type::const_iterator>;
 149   static_assert(std::is_same<decltype(cit), cpair>::value,
 150       "const equal_range returns pair<const_iterator, const_iterator>");
 151 }
 152
 153 void
 154 test06()
 155 {
 156   // PR libstdc++/78273
 157
 158   struct C {
 159     bool operator()(int l, int r) const { return l < r; }
 160
 161     struct Partition { };
 162
 163     bool operator()(int l, Partition) const { return l < 2; }
 164     bool operator()(Partition, int r) const { return 4 < r; }
 165
 166     using is_transparent = void;
 167   };
 168
 169   std::map<int, int, C> m{ {1,0}, {2,0}, {3,0}, {4, 0}, {5, 0} };
 170
 171   auto n = m.count(C::Partition{});
 172   VERIFY( n == 3 );
 173 }
 174
 175 int
 176 main()
 177 {
 178   test01();
 179   test02();
 180   test03();
 181   test04();
 182   test05();
 183   test06();
 184 }