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

   1 // { dg-do run { target c++20 } }
   2
   3 // Copyright (C) 2020-2024 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 <unordered_map>
  21 #include <testsuite_hooks.h>
  22
  23 struct aggressive_aggregate
  24 {
  25     int a;
  26     int b;
  27 };
  28
  29 void test_emplace()
  30 {
  31   std::unordered_map<int, aggressive_aggregate> x;
  32   auto emplaced = x.emplace(std::piecewise_construct,
  33                             std::tuple(0), std::tuple(1, 2));
  34   VERIFY(emplaced.first->second.a == 1);
  35   VERIFY(emplaced.first->second.b == 2);
  36   emplaced = x.emplace(std::piecewise_construct,
  37                        std::tuple(1), std::tuple(1));
  38   VERIFY(emplaced.first->second.a == 1);
  39   VERIFY(emplaced.first->second.b == 0);
  40   emplaced = x.emplace(std::piecewise_construct,
  41                        std::tuple(2), std::tuple());
  42   VERIFY(emplaced.first->second.a == 0);
  43   VERIFY(emplaced.first->second.b == 0);
  44 }
  45
  46 void test_emplace_hint()
  47 {
  48   std::unordered_map<int, aggressive_aggregate> x;
  49   auto it = x.emplace_hint(x.begin(),
  50                            std::piecewise_construct,
  51                            std::tuple(3), std::tuple(1, 2));
  52   VERIFY(it->second.a == 1);
  53   VERIFY(it->second.b == 2);
  54   it = x.emplace_hint(x.begin(),
  55                       std::piecewise_construct,
  56                       std::tuple(4), std::tuple(1));
  57   VERIFY(it->second.a == 1);
  58   VERIFY(it->second.b == 0);
  59   it = x.emplace_hint(x.begin(),
  60                       std::piecewise_construct,
  61                       std::tuple(5), std::tuple());
  62   VERIFY(it->second.a == 0);
  63   VERIFY(it->second.b == 0);
  64 }
  65
  66 void test_try_emplace_rvalue()
  67 {
  68   std::unordered_map<int, aggressive_aggregate> x;
  69   auto emplaced = x.try_emplace(6, 1, 2);
  70   VERIFY(emplaced.first->second.a == 1);
  71   VERIFY(emplaced.first->second.b == 2);
  72   emplaced = x.try_emplace(7, 1);
  73   VERIFY(emplaced.first->second.a == 1);
  74   VERIFY(emplaced.first->second.b == 0);
  75   emplaced = x.try_emplace(8);
  76   VERIFY(emplaced.first->second.a == 0);
  77   VERIFY(emplaced.first->second.b == 0);
  78 }
  79
  80 void test_try_emplace_lvalue()
  81 {
  82   std::unordered_map<int, aggressive_aggregate> x;
  83   int key = 9;
  84   auto emplaced = x.try_emplace(key, 1, 2);
  85   VERIFY(emplaced.first->second.a == 1);
  86   VERIFY(emplaced.first->second.b == 2);
  87   key = 10;
  88   emplaced = x.try_emplace(key, 1);
  89   VERIFY(emplaced.first->second.a == 1);
  90   VERIFY(emplaced.first->second.b == 0);
  91   key = 11;
  92   emplaced = x.try_emplace(key);
  93   VERIFY(emplaced.first->second.a == 0);
  94   VERIFY(emplaced.first->second.b == 0);
  95 }
  96
  97 void test_try_emplace_hint_rvalue()
  98 {
  99   std::unordered_map<int, aggressive_aggregate> x;
 100   auto it = x.try_emplace(x.begin(), 12, 1, 2);
 101   VERIFY(it->second.a == 1);
 102   VERIFY(it->second.b == 2);
 103   it = x.try_emplace(x.begin(), 13, 1);
 104   VERIFY(it->second.a == 1);
 105   VERIFY(it->second.b == 0);
 106   it = x.try_emplace(x.begin(), 14);
 107   VERIFY(it->second.a == 0);
 108   VERIFY(it->second.b == 0);
 109 }
 110
 111 void test_try_emplace_hint_lvalue()
 112 {
 113   std::unordered_map<int, aggressive_aggregate> x;
 114   int key = 15;
 115   auto it = x.try_emplace(x.begin(), key, 1, 2);
 116   VERIFY(it->second.a == 1);
 117   VERIFY(it->second.b == 2);
 118   key = 16;
 119   it = x.try_emplace(x.begin(), key, 1);
 120   VERIFY(it->second.a == 1);
 121   VERIFY(it->second.b == 0);
 122   key = 17;
 123   it = x.try_emplace(x.begin(), key);
 124   VERIFY(it->second.a == 0);
 125   VERIFY(it->second.b == 0);
 126 }
 127
 128 int main()
 129 {
 130   test_emplace();
 131   test_emplace_hint();
 132   test_try_emplace_rvalue();
 133   test_try_emplace_lvalue();
 134   test_try_emplace_hint_rvalue();
 135   test_try_emplace_hint_lvalue();
 136 }