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

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