libstdc++-v3/testsuite/util/regression/rand/assoc/detail/erase_fn_imps.hpp

   1 // -*- C++ -*-
   2
   3 // Copyright (C) 2005, 2006 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 terms
   7 // of the GNU General Public License as published by the Free Software
   8 // Foundation; either version 2, or (at your option) any later
   9 // version.
  10
  11 // This library is distributed in the hope that it will be useful, but
  12 // WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this library; see the file COPYING.  If not, write to
  18 // the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  19 // MA 02111-1307, USA.
  20
  21 // As a special exception, you may use this file as part of a free
  22 // software library without restriction.  Specifically, if other files
  23 // instantiate templates or use macros or inline functions from this
  24 // file, or you compile this file and link it with other files to
  25 // produce an executable, this file does not by itself cause the
  26 // resulting executable to be covered by the GNU General Public
  27 // License.  This exception does not however invalidate any other
  28 // reasons why the executable file might be covered by the GNU General
  29 // Public License.
  30
  31 // Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
  32
  33 // Permission to use, copy, modify, sell, and distribute this software
  34 // is hereby granted without fee, provided that the above copyright
  35 // notice appears in all copies, and that both that copyright notice
  36 // and this permission notice appear in supporting documentation. None
  37 // of the above authors, nor IBM Haifa Research Laboratories, make any
  38 // representation about the suitability of this software for any
  39 // purpose. It is provided "as is" without express or implied
  40 // warranty.
  41
  42 /**
  43  * @file erase_fn_imps.hpp
  44  * Containsert a random regression test for a specific container type.
  45  */
  46
  47 PB_DS_CLASS_T_DEC
  48 bool
  49 PB_DS_CLASS_C_DEC::
  50 erase()
  51 {
  52   PB_DS_TRACE("erase");
  53
  54   bool done = true;
  55
  56   PB_DS_SET_DESTRUCT_PRINT
  57
  58     m_alloc.set_throw_prob(0);
  59
  60   const key_type k =
  61     test_traits::generate_key(m_g, m_m);
  62
  63   m_alloc.set_throw_prob(m_tp);
  64
  65   try
  66     {
  67       const bool cntnd = m_p_c->find(k) != m_p_c->end();
  68
  69       PB_DS_THROW_IF_FAILED(
  70                             cntnd ==(m_native_c.find(test_traits::native_key(k)) != m_native_c.end()),
  71                             test_traits::key_to_string(k),
  72                             m_p_c,
  73                             & m_native_c);
  74
  75       const bool ersd = m_p_c->erase(k);
  76
  77       const bool native_ersd =
  78         m_native_c.erase(test_traits::native_key(k)) != 0;
  79
  80       PB_DS_THROW_IF_FAILED(
  81                             ersd == native_ersd,
  82                             ersd << " " << native_ersd,
  83                             m_p_c,
  84                             & m_native_c);
  85
  86       PB_DS_THROW_IF_FAILED(
  87                             m_p_c->find(k) == m_p_c->end(),
  88                             "",
  89                             m_p_c,
  90                             & m_native_c);
  91     }
  92   catch(__gnu_cxx::forced_exception_error& )
  93     {
  94       done = false;
  95
  96       PB_DS_THROW_IF_FAILED(            container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
  97     }
  98
  99   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
 100
 101   PB_DS_CANCEL_DESTRUCT_PRINT
 102
 103     return (done);
 104 }
 105
 106 PB_DS_CLASS_T_DEC
 107 bool
 108 PB_DS_CLASS_C_DEC::
 109 erase_if()
 110 {
 111   PB_DS_TRACE("erase_if");
 112
 113   bool done = true;
 114
 115   PB_DS_SET_DESTRUCT_PRINT
 116
 117     try
 118       {
 119         typedef
 120           typename std::iterator_traits<
 121           typename cntnr::iterator>::reference
 122           it_const_reference;
 123
 124         typedef
 125           typename test_traits::template erase_if_fn<
 126           value_type>
 127           erase_if_fn_t;
 128
 129         m_alloc.set_throw_prob(m_tp);
 130
 131         const size_t ersd =
 132           m_p_c->erase_if(erase_if_fn_t());
 133
 134         const size_t native_ersd =
 135           test_traits::erase_if(m_native_c);
 136
 137         PB_DS_THROW_IF_FAILED(
 138                               ersd == native_ersd,
 139                               static_cast<unsigned long>(ersd) << " " <<
 140                               static_cast<unsigned long>(native_ersd),
 141                               m_p_c,
 142                               & m_native_c);
 143       }
 144     catch(__gnu_cxx::forced_exception_error& )
 145       {
 146         done = false;
 147
 148         PB_DS_THROW_IF_FAILED(            container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
 149       }
 150
 151   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
 152
 153   PB_DS_CANCEL_DESTRUCT_PRINT
 154
 155     return (done);
 156 }
 157
 158 PB_DS_CLASS_T_DEC
 159 bool
 160 PB_DS_CLASS_C_DEC::
 161 erase_it()
 162 {
 163   enum
 164     {
 165       erase_iterators =
 166       container_traits::order_preserving
 167     };
 168
 169   return (erase_it_imp(__gnu_pbds::detail::integral_constant<int,erase_iterators>()));
 170 }
 171
 172 PB_DS_CLASS_T_DEC
 173 bool
 174 PB_DS_CLASS_C_DEC::
 175 erase_it_imp(__gnu_pbds::detail::false_type)
 176 {
 177   return (true);
 178 }
 179
 180 PB_DS_CLASS_T_DEC
 181 bool
 182 PB_DS_CLASS_C_DEC::
 183 erase_it_imp(__gnu_pbds::detail::true_type)
 184 {
 185   PB_DS_TRACE("erase_it");
 186
 187   bool done = true;
 188
 189   PB_DS_SET_DESTRUCT_PRINT
 190
 191     try
 192       {
 193         m_alloc.set_throw_prob(0);
 194
 195         const key_type k =
 196           test_traits::generate_key(m_g, m_m);
 197
 198         m_alloc.set_throw_prob(m_tp);
 199
 200         typename cntnr::iterator found_it = m_p_c->find(k);
 201
 202         typename native_type::iterator native_it = m_native_c.find(
 203                                                                    test_traits::native_key(k));
 204
 205         const bool found = found_it != m_p_c->end();
 206         const bool native_found = native_it != m_native_c.end();
 207
 208         PB_DS_THROW_IF_FAILED(
 209                               found == native_found,
 210                               found << " " <<    native_found,
 211                               m_p_c,
 212                               & m_native_c);
 213
 214         typename cntnr::const_iterator next_it = found_it;
 215         if (next_it != m_p_c->end())
 216           ++next_it;
 217
 218         typename cntnr::iterator next_ers_it =
 219           m_p_c->erase(found_it);
 220
 221         if (native_it != m_native_c.end())
 222           m_native_c.erase(native_it);
 223
 224         bool range_guarantee =
 225           __gnu_pbds::detail::is_same<
 226           typename container_traits::invalidation_guarantee,
 227           __gnu_pbds::range_invalidation_guarantee>::value ;
 228
 229         if (range_guarantee)
 230           PB_DS_THROW_IF_FAILED(                next_ers_it == next_it,  "",  m_p_c, & m_native_c);
 231       }
 232     catch(__gnu_cxx::forced_exception_error& )
 233       {
 234         done = false;
 235
 236         PB_DS_THROW_IF_FAILED(            container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
 237       }
 238
 239   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
 240
 241   PB_DS_CANCEL_DESTRUCT_PRINT
 242
 243     return (done);
 244 }
 245
 246 PB_DS_CLASS_T_DEC
 247 bool
 248 PB_DS_CLASS_C_DEC::
 249 erase_rev_it()
 250 {
 251   enum
 252     {
 253       erase_iterators =
 254       container_traits::order_preserving&&
 255       container_traits::reverse_iteration
 256     };
 257
 258   return (erase_rev_it_imp(__gnu_pbds::detail::integral_constant<int,erase_iterators>()));
 259 }
 260
 261 PB_DS_CLASS_T_DEC
 262 bool
 263 PB_DS_CLASS_C_DEC::
 264 erase_rev_it_imp(__gnu_pbds::detail::false_type)
 265 {
 266   return (true);
 267 }
 268
 269 PB_DS_CLASS_T_DEC
 270 bool
 271 PB_DS_CLASS_C_DEC::
 272 erase_rev_it_imp(__gnu_pbds::detail::true_type)
 273 {
 274   PB_DS_TRACE("erase_rev_it");
 275
 276   bool done = true;
 277
 278   PB_DS_SET_DESTRUCT_PRINT
 279
 280     try
 281       {
 282         m_alloc.set_throw_prob(0);
 283
 284         const key_type k =
 285           test_traits::generate_key(m_g, m_m);
 286
 287         m_alloc.set_throw_prob(m_tp);
 288
 289         typename cntnr::iterator found_it = m_p_c->find(k);
 290
 291         typename native_type::iterator native_it = m_native_c.find(
 292                                                                    test_traits::native_key(k));
 293
 294         typename cntnr::const_reverse_iterator next_it = found_it;
 295         if (next_it != m_p_c->end())
 296           ++next_it;
 297
 298         typename cntnr::reverse_iterator next_ers_it =
 299           m_p_c->erase((typename cntnr::reverse_iterator)found_it);
 300
 301         PB_DS_THROW_IF_FAILED(            next_ers_it == next_it, "", m_p_c, & m_native_c);
 302
 303         if (native_it != m_native_c.end())
 304           m_native_c.erase(native_it);
 305       }
 306     catch(__gnu_cxx::forced_exception_error& )
 307       {
 308         done = false;
 309
 310         PB_DS_THROW_IF_FAILED(            container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
 311       }
 312
 313   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
 314
 315   PB_DS_CANCEL_DESTRUCT_PRINT
 316
 317     return (done);
 318 }
 319