libstdc++-v3/testsuite/23_containers/map/modifiers/try_emplace/1.cc

   1 // { dg-do run { target c++17 } }
   2
   3 // Copyright (C) 2015-2021 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING3.  If not see
  18 // <http://www.gnu.org/licenses/>.
  19
  20 #include <utility>
  21 #include <map>
  22 #include <testsuite_hooks.h>
  23
  24 struct Val
  25 {
  26   bool moved_from_ctor = false;
  27   bool moved_from_assign = false;
  28   int val;
  29   Val(int val = 0) : val(val) {}
  30   Val(const Val& other) : val(other.val)
  31   {
  32   }
  33   Val(Val&& other) : val(other.val)
  34   {
  35     other.moved_from_ctor = true;
  36   }
  37   Val& operator=(Val&& other)
  38   {
  39     val = other.val;
  40     other.moved_from_assign = true;
  41     return *this;
  42   }
  43 };
  44
  45 bool operator<(const Val& a, const Val& b)
  46 {
  47   return a.val < b.val;
  48 }
  49
  50 void test01()
  51 {
  52   typedef std::map<int, Val> Map;
  53   Map m;
  54   auto res1 = m.try_emplace(0, Val(5));
  55   VERIFY(res1.second);
  56   VERIFY(res1.first != m.end());
  57   VERIFY(m[0].val == 5);
  58   Val v1{6};
  59   VERIFY(m.size() == 1);
  60   auto res2 = m.try_emplace(0, std::move(v1));
  61   VERIFY(!res2.second);
  62   VERIFY(res2.first == res1.first);
  63   VERIFY(m[0].val == 5);
  64   VERIFY(!v1.moved_from_ctor);
  65   VERIFY(!v1.moved_from_assign);
  66   VERIFY(m.size() == 1);
  67   auto res3 = m.try_emplace(1, std::move(v1));
  68   VERIFY(res3.first != res1.first && res3.first != m.end());
  69   VERIFY(res3.second);
  70   VERIFY(m[0].val == 5);
  71   VERIFY(m[1].val == 6);
  72   VERIFY(v1.moved_from_ctor);
  73   VERIFY(!v1.moved_from_assign);
  74   VERIFY(m.size() == 2);
  75 }
  76
  77 void test02()
  78 {
  79   typedef std::map<int, Val> Map;
  80   Map m;
  81   auto res1 = m.try_emplace(m.begin(), 0, Val(5));
  82   VERIFY(res1 != m.end());
  83   VERIFY(m[0].val == 5);
  84   Val v1{6};
  85   VERIFY(m.size() == 1);
  86   auto res2 = m.try_emplace(m.begin(), 0, std::move(v1));
  87   VERIFY(res2 == res1);
  88   VERIFY(m[0].val == 5);
  89   VERIFY(!v1.moved_from_ctor);
  90   VERIFY(!v1.moved_from_assign);
  91   VERIFY(m.size() == 1);
  92   auto res3 = m.try_emplace(m.begin(), 1, std::move(v1));
  93   VERIFY(res3 != res1 && res3 != m.end());
  94   VERIFY(m[0].val == 5);
  95   VERIFY(m[1].val == 6);
  96   VERIFY(v1.moved_from_ctor);
  97   VERIFY(!v1.moved_from_assign);
  98   VERIFY(m.size() == 2);
  99 }
 100
 101 void test03()
 102 {
 103   typedef std::map<Val, Val> Map;
 104   Map m;
 105   auto res1 = m.try_emplace(0, Val(5));
 106   VERIFY(res1.second);
 107   VERIFY(res1.first != m.end());
 108   VERIFY(m[0].val == 5);
 109   Val k1{0};
 110   Val v1{6};
 111   VERIFY(m.size() == 1);
 112   auto res2 = m.try_emplace(std::move(k1), std::move(v1));
 113   VERIFY(!res2.second);
 114   VERIFY(res2.first == res1.first);
 115   VERIFY(m[0].val == 5);
 116   VERIFY(!k1.moved_from_ctor);
 117   VERIFY(!k1.moved_from_assign);
 118   VERIFY(!v1.moved_from_ctor);
 119   VERIFY(!v1.moved_from_assign);
 120   VERIFY(m.size() == 1);
 121   Val k2{1};
 122   auto res3 = m.try_emplace(std::move(k2), std::move(v1));
 123   VERIFY(res3.first != res1.first && res3.first != m.end());
 124   VERIFY(res3.second);
 125   VERIFY(m[0].val == 5);
 126   VERIFY(m[1].val == 6);
 127   VERIFY(k2.moved_from_ctor);
 128   VERIFY(!k2.moved_from_assign);
 129   VERIFY(v1.moved_from_ctor);
 130   VERIFY(!v1.moved_from_assign);
 131   VERIFY(m.size() == 2);
 132 }
 133
 134 void test04()
 135 {
 136   typedef std::map<Val, Val> Map;
 137   Map m;
 138   auto res1 = m.try_emplace(m.begin(), 0, Val(5));
 139   VERIFY(res1 != m.end());
 140   VERIFY(m[0].val == 5);
 141   Val k1{0};
 142   Val v1{6};
 143   VERIFY(m.size() == 1);
 144   auto res2 = m.try_emplace(m.begin(), std::move(k1), std::move(v1));
 145   VERIFY(res2 == res1);
 146   VERIFY(m[0].val == 5);
 147   VERIFY(!k1.moved_from_ctor);
 148   VERIFY(!k1.moved_from_assign);
 149   VERIFY(!v1.moved_from_ctor);
 150   VERIFY(!v1.moved_from_assign);
 151   VERIFY(m.size() == 1);
 152   Val k2{1};
 153   auto res3 = m.try_emplace(m.begin(), std::move(k2), std::move(v1));
 154   VERIFY(res3 != res1 && res3 != m.end());
 155   VERIFY(m[0].val == 5);
 156   VERIFY(m[1].val == 6);
 157   VERIFY(k2.moved_from_ctor);
 158   VERIFY(!k2.moved_from_assign);
 159   VERIFY(v1.moved_from_ctor);
 160   VERIFY(!v1.moved_from_assign);
 161   VERIFY(m.size() == 2);
 162 }
 163
 164 void test05()
 165 {
 166   typedef std::map<int, Val> Map;
 167   Map m;
 168   auto res1 = m.try_emplace(0, Val(5));
 169   VERIFY(res1.second);
 170   VERIFY(res1.first != m.end());
 171   VERIFY(m[0].val == 5);
 172   Val v1{6};
 173   VERIFY(m.size() == 1);
 174   auto res2 = m.try_emplace(0, v1);
 175   VERIFY(!res2.second);
 176   VERIFY(res2.first == res1.first);
 177   VERIFY(m[0].val == 5);
 178   VERIFY(!v1.moved_from_ctor);
 179   VERIFY(!v1.moved_from_assign);
 180   VERIFY(m.size() == 1);
 181   auto res3 = m.try_emplace(1, v1);
 182   VERIFY(res3.first != res1.first && res3.first != m.end());
 183   VERIFY(res3.second);
 184   VERIFY(m[0].val == 5);
 185   VERIFY(m[1].val == 6);
 186   VERIFY(!v1.moved_from_ctor);
 187   VERIFY(!v1.moved_from_assign);
 188   VERIFY(m.size() == 2);
 189 }
 190
 191 void test06()
 192 {
 193   typedef std::map<int, Val> Map;
 194   Map m;
 195   auto res1 = m.try_emplace(m.begin(), 0, Val(5));
 196   VERIFY(res1 != m.end());
 197   VERIFY(m[0].val == 5);
 198   Val v1{6};
 199   VERIFY(m.size() == 1);
 200   auto res2 = m.try_emplace(m.begin(), 0, v1);
 201   VERIFY(res2 == res1);
 202   VERIFY(m[0].val == 5);
 203   VERIFY(!v1.moved_from_ctor);
 204   VERIFY(!v1.moved_from_assign);
 205   VERIFY(m.size() == 1);
 206   auto res3 = m.try_emplace(m.begin(), 1, v1);
 207   VERIFY(res3 != res1 && res3 != m.end());
 208   VERIFY(m[0].val == 5);
 209   VERIFY(m[1].val == 6);
 210   VERIFY(!v1.moved_from_ctor);
 211   VERIFY(!v1.moved_from_assign);
 212   VERIFY(m.size() == 2);
 213 }
 214
 215 void test07()
 216 {
 217   typedef std::map<Val, Val> Map;
 218   Map m;
 219   auto res1 = m.try_emplace(0, Val(5));
 220   VERIFY(res1.second);
 221   VERIFY(res1.first != m.end());
 222   VERIFY(m[0].val == 5);
 223   Val k1{0};
 224   Val v1{6};
 225   VERIFY(m.size() == 1);
 226   auto res2 = m.try_emplace(k1, v1);
 227   VERIFY(!res2.second);
 228   VERIFY(res2.first == res1.first);
 229   VERIFY(m[0].val == 5);
 230   VERIFY(!k1.moved_from_ctor);
 231   VERIFY(!k1.moved_from_assign);
 232   VERIFY(!v1.moved_from_ctor);
 233   VERIFY(!v1.moved_from_assign);
 234   VERIFY(m.size() == 1);
 235   Val k2{1};
 236   auto res3 = m.try_emplace(k2, v1);
 237   VERIFY(res3.first != res1.first && res3.first != m.end());
 238   VERIFY(res3.second);
 239   VERIFY(m[0].val == 5);
 240   VERIFY(m[1].val == 6);
 241   VERIFY(!k2.moved_from_ctor);
 242   VERIFY(!k2.moved_from_assign);
 243   VERIFY(!v1.moved_from_ctor);
 244   VERIFY(!v1.moved_from_assign);
 245   VERIFY(m.size() == 2);
 246 }
 247
 248 void test08()
 249 {
 250   typedef std::map<Val, Val> Map;
 251   Map m;
 252   auto res1 = m.try_emplace(m.begin(), 0, Val(5));
 253   VERIFY(res1 != m.end());
 254   VERIFY(m[0].val == 5);
 255   Val k1{0};
 256   Val v1{6};
 257   VERIFY(m.size() == 1);
 258   auto res2 = m.try_emplace(m.begin(), k1, v1);
 259   VERIFY(res2 == res1);
 260   VERIFY(m[0].val == 5);
 261   VERIFY(!k1.moved_from_ctor);
 262   VERIFY(!k1.moved_from_assign);
 263   VERIFY(!v1.moved_from_ctor);
 264   VERIFY(!v1.moved_from_assign);
 265   VERIFY(m.size() == 1);
 266   Val k2{1};
 267   auto res3 = m.try_emplace(m.begin(), k2, v1);
 268   VERIFY(res3 != res1 && res3 != m.end());
 269   VERIFY(m[0].val == 5);
 270   VERIFY(m[1].val == 6);
 271   VERIFY(!k2.moved_from_ctor);
 272   VERIFY(!k2.moved_from_assign);
 273   VERIFY(!v1.moved_from_ctor);
 274   VERIFY(!v1.moved_from_assign);
 275   VERIFY(m.size() == 2);
 276 }
 277
 278 int main()
 279 {
 280   test01();
 281   test02();
 282   test03();
 283   test04();
 284   test05();
 285   test06();
 286   test07();
 287   test08();
 288   return 0;
 289 }