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

   1 // { dg-do run { target c++17 } }
   2
   3 // Copyright (C) 2015-2022 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 <unordered_map>
  22 #include <functional>
  23 #include <testsuite_hooks.h>
  24
  25 struct Val
  26 {
  27   bool moved_from_ctor = false;
  28   bool moved_from_assign = false;
  29   int val;
  30   Val(int val = 0) : val(val) {}
  31   Val(const Val& other) : val(other.val)
  32   {
  33   }
  34   Val(Val&& other) : val(other.val)
  35   {
  36     other.moved_from_ctor = true;
  37   }
  38   Val& operator=(Val&& other)
  39   {
  40     val = other.val;
  41     other.moved_from_assign = true;
  42     return *this;
  43   }
  44 };
  45
  46 bool operator==(const Val& a, const Val& b)
  47 {
  48   return a.val == b.val;
  49 }
  50
  51 namespace std
  52 {
  53   template <> struct hash<Val>
  54    {
  55      using result_type = size_t;
  56      using argument_type = Val;
  57
  58      size_t
  59      operator()(const Val& t) const
  60        noexcept
  61      {
  62        return hash<int>{}(t.val);
  63      }
  64    };
  65 }
  66
  67 void test01()
  68 {
  69   typedef std::unordered_map<int, Val> Map;
  70   Map m;
  71   auto res1 = m.try_emplace(0, Val(5));
  72   VERIFY(res1.second);
  73   VERIFY(res1.first != m.end());
  74   VERIFY(m[0].val == 5);
  75   Val v1{6};
  76   VERIFY(m.size() == 1);
  77   auto res2 = m.try_emplace(0, std::move(v1));
  78   VERIFY(!res2.second);
  79   VERIFY(res2.first == res1.first);
  80   VERIFY(m[0].val == 5);
  81   VERIFY(!v1.moved_from_ctor);
  82   VERIFY(!v1.moved_from_assign);
  83   VERIFY(m.size() == 1);
  84   auto res3 = m.try_emplace(1, std::move(v1));
  85   VERIFY(res3.first != res1.first && res3.first != m.end());
  86   VERIFY(res3.second);
  87   VERIFY(m[0].val == 5);
  88   VERIFY(m[1].val == 6);
  89   VERIFY(v1.moved_from_ctor);
  90   VERIFY(!v1.moved_from_assign);
  91   VERIFY(m.size() == 2);
  92 }
  93
  94 void test02()
  95 {
  96   typedef std::unordered_map<int, Val> Map;
  97   Map m;
  98   auto res1 = m.try_emplace(m.begin(), 0, Val(5));
  99   VERIFY(res1 != m.end());
 100   VERIFY(m[0].val == 5);
 101   Val v1{6};
 102   VERIFY(m.size() == 1);
 103   auto res2 = m.try_emplace(m.begin(), 0, std::move(v1));
 104   VERIFY(res2 == res1);
 105   VERIFY(m[0].val == 5);
 106   VERIFY(!v1.moved_from_ctor);
 107   VERIFY(!v1.moved_from_assign);
 108   VERIFY(m.size() == 1);
 109   auto res3 = m.try_emplace(m.begin(), 1, std::move(v1));
 110   VERIFY(res3 != res1 && res3 != m.end());
 111   VERIFY(m[0].val == 5);
 112   VERIFY(m[1].val == 6);
 113   VERIFY(v1.moved_from_ctor);
 114   VERIFY(!v1.moved_from_assign);
 115   VERIFY(m.size() == 2);
 116 }
 117
 118 void test03()
 119 {
 120   typedef std::unordered_map<Val, Val> Map;
 121   Map m;
 122   auto res1 = m.try_emplace(0, Val(5));
 123   VERIFY(res1.second);
 124   VERIFY(res1.first != m.end());
 125   VERIFY(m[0].val == 5);
 126   Val k1{0};
 127   Val v1{6};
 128   VERIFY(m.size() == 1);
 129   auto res2 = m.try_emplace(std::move(k1), std::move(v1));
 130   VERIFY(!res2.second);
 131   VERIFY(res2.first == res1.first);
 132   VERIFY(m[0].val == 5);
 133   VERIFY(!k1.moved_from_ctor);
 134   VERIFY(!k1.moved_from_assign);
 135   VERIFY(!v1.moved_from_ctor);
 136   VERIFY(!v1.moved_from_assign);
 137   VERIFY(m.size() == 1);
 138   Val k2{1};
 139   auto res3 = m.try_emplace(std::move(k2), std::move(v1));
 140   VERIFY(res3.first != res1.first && res3.first != m.end());
 141   VERIFY(res3.second);
 142   VERIFY(m[0].val == 5);
 143   VERIFY(m[1].val == 6);
 144   VERIFY(k2.moved_from_ctor);
 145   VERIFY(!k2.moved_from_assign);
 146   VERIFY(v1.moved_from_ctor);
 147   VERIFY(!v1.moved_from_assign);
 148   VERIFY(m.size() == 2);
 149 }
 150
 151 void test04()
 152 {
 153   typedef std::unordered_map<Val, Val> Map;
 154   Map m;
 155   auto res1 = m.try_emplace(m.begin(), 0, Val(5));
 156   VERIFY(res1 != m.end());
 157   VERIFY(m[0].val == 5);
 158   Val k1{0};
 159   Val v1{6};
 160   VERIFY(m.size() == 1);
 161   auto res2 = m.try_emplace(m.begin(), std::move(k1), std::move(v1));
 162   VERIFY(res2 == res1);
 163   VERIFY(m[0].val == 5);
 164   VERIFY(!k1.moved_from_ctor);
 165   VERIFY(!k1.moved_from_assign);
 166   VERIFY(!v1.moved_from_ctor);
 167   VERIFY(!v1.moved_from_assign);
 168   VERIFY(m.size() == 1);
 169   Val k2{1};
 170   auto res3 = m.try_emplace(m.begin(), std::move(k2), std::move(v1));
 171   VERIFY(res3 != res1 && res3 != m.end());
 172   VERIFY(m[0].val == 5);
 173   VERIFY(m[1].val == 6);
 174   VERIFY(k2.moved_from_ctor);
 175   VERIFY(!k2.moved_from_assign);
 176   VERIFY(v1.moved_from_ctor);
 177   VERIFY(!v1.moved_from_assign);
 178   VERIFY(m.size() == 2);
 179 }
 180
 181 void test05()
 182 {
 183   typedef std::unordered_map<int, Val> Map;
 184   Map m;
 185   auto res1 = m.try_emplace(0, Val(5));
 186   VERIFY(res1.second);
 187   VERIFY(res1.first != m.end());
 188   VERIFY(m[0].val == 5);
 189   Val v1{6};
 190   VERIFY(m.size() == 1);
 191   auto res2 = m.try_emplace(0, std::move(v1));
 192   VERIFY(!res2.second);
 193   VERIFY(res2.first == res1.first);
 194   VERIFY(m[0].val == 5);
 195   VERIFY(!v1.moved_from_ctor);
 196   VERIFY(!v1.moved_from_assign);
 197   VERIFY(m.size() == 1);
 198   auto res3 = m.try_emplace(1, std::move(v1));
 199   VERIFY(res3.first != res1.first && res3.first != m.end());
 200   VERIFY(res3.second);
 201   VERIFY(m[0].val == 5);
 202   VERIFY(m[1].val == 6);
 203   VERIFY(v1.moved_from_ctor);
 204   VERIFY(!v1.moved_from_assign);
 205   VERIFY(m.size() == 2);
 206 }
 207
 208 void test06()
 209 {
 210   typedef std::unordered_map<int, Val> Map;
 211   Map m;
 212   auto res1 = m.try_emplace(m.begin(), 0, Val(5));
 213   VERIFY(res1 != m.end());
 214   VERIFY(m[0].val == 5);
 215   Val v1{6};
 216   VERIFY(m.size() == 1);
 217   auto res2 = m.try_emplace(m.begin(), 0, std::move(v1));
 218   VERIFY(res2 == res1);
 219   VERIFY(m[0].val == 5);
 220   VERIFY(!v1.moved_from_ctor);
 221   VERIFY(!v1.moved_from_assign);
 222   VERIFY(m.size() == 1);
 223   auto res3 = m.try_emplace(m.begin(), 1, std::move(v1));
 224   VERIFY(res3 != res1 && res3 != m.end());
 225   VERIFY(m[0].val == 5);
 226   VERIFY(m[1].val == 6);
 227   VERIFY(v1.moved_from_ctor);
 228   VERIFY(!v1.moved_from_assign);
 229   VERIFY(m.size() == 2);
 230 }
 231
 232 void test07()
 233 {
 234   typedef std::unordered_map<Val, Val> Map;
 235   Map m;
 236   auto res1 = m.try_emplace(0, Val(5));
 237   VERIFY(res1.second);
 238   VERIFY(res1.first != m.end());
 239   VERIFY(m[0].val == 5);
 240   Val k1{0};
 241   Val v1{6};
 242   VERIFY(m.size() == 1);
 243   auto res2 = m.try_emplace(k1, v1);
 244   VERIFY(!res2.second);
 245   VERIFY(res2.first == res1.first);
 246   VERIFY(m[0].val == 5);
 247   VERIFY(!k1.moved_from_ctor);
 248   VERIFY(!k1.moved_from_assign);
 249   VERIFY(!v1.moved_from_ctor);
 250   VERIFY(!v1.moved_from_assign);
 251   VERIFY(m.size() == 1);
 252   Val k2{1};
 253   auto res3 = m.try_emplace(k2, v1);
 254   VERIFY(res3.first != res1.first && res3.first != m.end());
 255   VERIFY(res3.second);
 256   VERIFY(m[0].val == 5);
 257   VERIFY(m[1].val == 6);
 258   VERIFY(!k2.moved_from_ctor);
 259   VERIFY(!k2.moved_from_assign);
 260   VERIFY(!v1.moved_from_ctor);
 261   VERIFY(!v1.moved_from_assign);
 262   VERIFY(m.size() == 2);
 263 }
 264
 265 void test08()
 266 {
 267   typedef std::unordered_map<Val, Val> Map;
 268   Map m;
 269   auto res1 = m.try_emplace(m.begin(), 0, Val(5));
 270   VERIFY(res1 != m.end());
 271   VERIFY(m[0].val == 5);
 272   Val k1{0};
 273   Val v1{6};
 274   VERIFY(m.size() == 1);
 275   auto res2 = m.try_emplace(m.begin(), k1, v1);
 276   VERIFY(res2 == res1);
 277   VERIFY(m[0].val == 5);
 278   VERIFY(!k1.moved_from_ctor);
 279   VERIFY(!k1.moved_from_assign);
 280   VERIFY(!v1.moved_from_ctor);
 281   VERIFY(!v1.moved_from_assign);
 282   VERIFY(m.size() == 1);
 283   Val k2{1};
 284   auto res3 = m.try_emplace(m.begin(), k2, v1);
 285   VERIFY(res3 != res1 && res3 != m.end());
 286   VERIFY(m[0].val == 5);
 287   VERIFY(m[1].val == 6);
 288   VERIFY(!k2.moved_from_ctor);
 289   VERIFY(!k2.moved_from_assign);
 290   VERIFY(!v1.moved_from_ctor);
 291   VERIFY(!v1.moved_from_assign);
 292   VERIFY(m.size() == 2);
 293 }
 294
 295 int main()
 296 {
 297   test01();
 298   test02();
 299   test03();
 300   test04();
 301   test05();
 302   test06();
 303   test07();
 304   test08();
 305   return 0;
 306 }