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

   1 // Copyright (C) 2015-2017 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 <set>
  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::set<int, Cmp>;
  37
  38 test_type x{ 1, 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 == 1 );
  48   it = x.find(2L);
  49   VERIFY( it == x.end() );
  50
  51   auto cit = cx.find(3L);
  52   VERIFY( cit != cx.end() && *cit == 3 );
  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 == 1 );
  89   it = x.lower_bound(2L);
  90   VERIFY( it != x.end() && *it == 3 );
  91
  92   auto cit = cx.lower_bound(1L);
  93   VERIFY( cit != cx.end() && *cit == 1 );
  94   cit = cx.lower_bound(2L);
  95   VERIFY( cit != cx.end() && *cit == 3 );
  96
  97   VERIFY( Cmp::count == 0);
  98 }
  99
 100 void
 101 test04()
 102 {
 103   Cmp::count = 0;
 104
 105   auto it = x.upper_bound(1L);
 106   VERIFY( it != x.end() && *it == 3 );
 107   it = x.upper_bound(5L);
 108   VERIFY( it == x.end() );
 109
 110   auto cit = cx.upper_bound(1L);
 111   VERIFY( cit != cx.end() && *cit == 3 );
 112   cit = cx.upper_bound(5L);
 113   VERIFY( cit == cx.end() );
 114
 115   VERIFY( Cmp::count == 0);
 116 }
 117
 118 void
 119 test05()
 120 {
 121   Cmp::count = 0;
 122
 123   auto it = x.equal_range(1L);
 124   VERIFY( it.first != it.second && *it.first == 1 );
 125   it = x.equal_range(2L);
 126   VERIFY( it.first == it.second && it.first != x.end() );
 127
 128   auto cit = cx.equal_range(1L);
 129   VERIFY( cit.first != cit.second && *cit.first == 1 );
 130   cit = cx.equal_range(2L);
 131   VERIFY( cit.first == cit.second && cit.first != cx.end() );
 132
 133   VERIFY( Cmp::count == 0);
 134 }
 135
 136 void
 137 test06()
 138 {
 139   // https://gcc.gnu.org/ml/libstdc++/2015-01/msg00176.html
 140   // Verify the new function template overloads do not cause problems
 141   // when the comparison function is not transparent.
 142   struct I
 143   {
 144     int i;
 145     operator int() const { return i; }
 146   };
 147
 148   std::set<int> s;
 149   I i = { };
 150   s.find(i);
 151 }
 152
 153 int
 154 main()
 155 {
 156   test01();
 157   test02();
 158   test03();
 159   test04();
 160   test05();
 161   test06();
 162 }