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

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