libstdc++-v3/testsuite/util/testsuite_containers.h

   1 // -*- C++ -*-
   2
   3 // Copyright (C) 2009-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 terms
   7 // of the GNU General Public License as published by the Free Software
   8 // Foundation; either version 3, 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 along
  17 // with this library; see the file COPYING3.  If not see
  18 // <http://www.gnu.org/licenses/>.
  19
  20 #ifndef _GLIBCXX_TESTSUITE_CONTAINERS_H
  21 #define _GLIBCXX_TESTSUITE_CONTAINERS_H
  22
  23 #include <bits/boost_concept_check.h>
  24 #include <cassert>
  25 #include <testsuite_container_traits.h>
  26 #include <utility> // for rel_ops.
  27
  28 // Container requirement testing.
  29 namespace __gnu_test
  30 {
  31   // Compile-time typedef testing.
  32   template<typename _Tp, bool _Bt = traits<_Tp>::is_container::value>
  33     struct basic_types
  34     {
  35       // Base container requirements (table 80)
  36       typedef _Tp                                       test_type;
  37       typedef typename test_type::value_type            value_type;
  38       typedef typename test_type::pointer               pointer;
  39       typedef typename test_type::const_pointer         const_pointer;
  40       typedef typename test_type::reference             reference;
  41       typedef typename test_type::const_reference       const_reference;
  42       typedef typename test_type::iterator              iterator;
  43       typedef typename test_type::const_iterator        const_iterator;
  44       typedef typename test_type::size_type             size_type;
  45       typedef typename test_type::difference_type       difference_type;
  46     };
  47
  48   // Conditional typedef testing, positive.
  49   template<typename _Tp, bool _Bt = traits<_Tp>::is_reversible::value>
  50     struct reversible_types
  51     {
  52       // Reversible container requirements (table 81)
  53       typedef _Tp                                        test_type;
  54       typedef typename test_type::reverse_iterator       reverse_iterator;
  55       typedef typename test_type::const_reverse_iterator const_reverse_iterator;
  56     };
  57
  58   template<typename _Tp, bool _Bt = traits<_Tp>::is_allocator_aware::value>
  59     struct allocator_aware_types
  60     {
  61       // _Alloc-aware requirements (table 82)
  62       typedef _Tp                                        test_type;
  63       typedef typename test_type::allocator_type         allocator_type;
  64     };
  65
  66   template<typename _Tp, bool _Bt = traits<_Tp>::is_associative::value>
  67     struct associative_types
  68     {
  69       // Associative container requirements (table 85)
  70       typedef _Tp                                        test_type;
  71       typedef typename test_type::key_type               key_type;
  72       typedef typename test_type::key_compare            key_compare;
  73       typedef typename test_type::value_compare          value_compare;
  74     };
  75
  76   template<typename _Tp, bool = traits<_Tp>::is_unordered::value>
  77     struct unordered_types
  78     {
  79       // Unordered associative container requirements (table 87)
  80       typedef _Tp                                        test_type;
  81       typedef typename test_type::key_type               key_type;
  82       typedef typename test_type::hasher                 hasher;
  83       typedef typename test_type::key_equal              key_equal;
  84       typedef typename test_type::local_iterator         local_iterator;
  85       typedef typename test_type::const_local_iterator   const_local_iterator;
  86     };
  87
  88   template<typename _Tp, bool _Bt = traits<_Tp>::is_mapped::value>
  89     struct mapped_types
  90     {
  91       typedef _Tp                                        test_type;
  92       typedef typename test_type::mapped_type            mapped_type;
  93     };
  94
  95   template<typename _Tp, bool = traits<_Tp>::is_adaptor::value>
  96     struct adaptor_types
  97     {
  98       // Container adaptor requirements.
  99       typedef _Tp                                       test_type;
 100       typedef typename test_type::value_type            value_type;
 101       typedef typename test_type::reference             reference;
 102       typedef typename test_type::const_reference       const_reference;
 103       typedef typename test_type::size_type             size_type;
 104       typedef typename test_type::container_type        container_type;
 105     };
 106
 107   // Conditional typedef testing, negative.
 108   template<typename _Tp>
 109     struct basic_types<_Tp, false> { };
 110
 111   template<typename _Tp>
 112     struct adaptor_types<_Tp, false> { };
 113
 114   template<typename _Tp>
 115     struct reversible_types<_Tp, false> { };
 116
 117   template<typename _Tp>
 118     struct allocator_aware_types<_Tp, false> { };
 119
 120   template<typename _Tp>
 121     struct associative_types<_Tp, false> { };
 122
 123   template<typename _Tp>
 124     struct unordered_types<_Tp, false> { };
 125
 126   template<typename _Tp>
 127     struct mapped_types<_Tp, false> { };
 128
 129   // Primary template.
 130   template<typename _Tp>
 131     struct types
 132     : basic_types<_Tp>, adaptor_types<_Tp>, reversible_types<_Tp>,
 133       allocator_aware_types<_Tp>, associative_types<_Tp>,
 134       unordered_types<_Tp>, mapped_types<_Tp>
 135     { };
 136
 137
 138   // Run-time test for constant_iterator requirements.
 139   template<typename _Tp, bool = traits<_Tp>::is_allocator_aware::value>
 140     struct populate
 141     {
 142       populate(_Tp& container)
 143       {
 144         // Avoid uninitialized warnings, requires DefaultContructible.
 145         typedef typename _Tp::value_type value_type;
 146         container.insert(container.begin(), value_type());
 147         container.insert(container.begin(), value_type());
 148       }
 149   };
 150
 151   template<typename _Tp>
 152     struct populate<_Tp, false>
 153     {
 154       populate(_Tp& container) { }
 155     };
 156
 157   template<typename _Tp, bool = traits<_Tp>::is_reversible::value>
 158     struct reverse_members
 159     {
 160       reverse_members(_Tp& container)
 161       {
 162         assert( container.crbegin() == container.rbegin() );
 163         assert( container.crend() == container.rend() );
 164         assert( container.crbegin() != container.crend() );
 165       }
 166     };
 167
 168   template<typename _Tp>
 169     struct reverse_members<_Tp, false>
 170     {
 171       reverse_members(_Tp&) { }
 172     };
 173
 174   template<typename _Iterator,
 175            bool _Mutable,
 176            typename = typename std::iterator_traits<_Iterator>::iterator_category>
 177     struct iterator_concept_checks;
 178
 179 #if __cplusplus >= 201103L
 180   // DR 691.
 181   template<typename _Tp>
 182     struct forward_members_unordered
 183     {
 184       forward_members_unordered(const typename _Tp::value_type& v)
 185       {
 186         // Make sure that even if rel_ops is injected there is no ambiguity
 187         // when comparing iterators.
 188         using namespace std::rel_ops;
 189
 190         typedef _Tp                                     test_type;
 191         test_type container;
 192         container.insert(v);
 193
 194         iterator_concept_checks<typename _Tp::local_iterator, false> cc;
 195         iterator_concept_checks<typename _Tp::const_local_iterator,
 196                                 false> ccc;
 197
 198         assert( container.cbegin(0) == container.begin(0) );
 199         assert( container.cend(0) == container.end(0) );
 200         const auto bn = container.bucket(1);
 201         auto clit = container.cbegin(bn);
 202         assert( clit != container.cend(bn) );
 203         assert( clit != container.end(bn) );
 204         assert( clit++ == container.cbegin(bn) );
 205         assert( clit == container.end(bn) );
 206
 207         clit = container.cbegin(bn);
 208         assert( ++clit == container.cend(bn) );
 209
 210         assert( container.begin(bn) != container.cend(bn) );
 211       }
 212     };
 213 #endif
 214
 215   template<typename _Iterator>
 216     struct iterator_concept_checks<_Iterator, false,
 217                                    std::forward_iterator_tag>
 218     {
 219       iterator_concept_checks()
 220       {
 221         using namespace __gnu_cxx;
 222         __function_requires<_ForwardIteratorConcept<_Iterator>>();
 223       }
 224     };
 225
 226   template<typename _Iterator>
 227     struct iterator_concept_checks<_Iterator, true,
 228                                    std::forward_iterator_tag>
 229     {
 230       iterator_concept_checks()
 231       {
 232         using namespace __gnu_cxx;
 233         __function_requires<_Mutable_ForwardIteratorConcept<_Iterator>>();
 234       }
 235     };
 236
 237   template<typename _Iterator>
 238     struct iterator_concept_checks<_Iterator, false,
 239                                    std::bidirectional_iterator_tag>
 240     {
 241       iterator_concept_checks()
 242       {
 243         using namespace __gnu_cxx;
 244         __function_requires<_BidirectionalIteratorConcept<_Iterator>>();
 245       }
 246     };
 247
 248   template<typename _Iterator>
 249     struct iterator_concept_checks<_Iterator, true,
 250                                    std::bidirectional_iterator_tag>
 251     {
 252       iterator_concept_checks()
 253       {
 254         using namespace __gnu_cxx;
 255         __function_requires<_Mutable_BidirectionalIteratorConcept<_Iterator>>();
 256       }
 257     };
 258
 259   template<typename _Iterator>
 260     struct iterator_concept_checks<_Iterator, false,
 261                                    std::random_access_iterator_tag>
 262     {
 263       iterator_concept_checks()
 264       {
 265         using namespace __gnu_cxx;
 266         __function_requires<_RandomAccessIteratorConcept<_Iterator>>();
 267       }
 268     };
 269
 270   template<typename _Iterator>
 271     struct iterator_concept_checks<_Iterator, true,
 272                                    std::random_access_iterator_tag>
 273     {
 274       iterator_concept_checks()
 275       {
 276         using namespace __gnu_cxx;
 277         __function_requires<_Mutable_RandomAccessIteratorConcept<_Iterator>>();
 278       }
 279     };
 280
 281   template<typename _Tp>
 282     struct forward_members
 283     {
 284       forward_members(_Tp& container)
 285       {
 286         // Make sure that even if rel_ops is injected there is no ambiguity
 287         // when comparing iterators.
 288         using namespace std::rel_ops;
 289
 290         typedef traits<_Tp> traits_type;
 291         iterator_concept_checks<typename _Tp::iterator,
 292                                 !(traits_type::is_associative::value
 293                                   || traits_type::is_unordered::value)> cc;
 294         iterator_concept_checks<typename _Tp::const_iterator, false> ccc;
 295
 296         assert( container.cbegin() == container.begin() );
 297         assert( container.end() == container.cend() );
 298         assert( container.cbegin() != container.cend() );
 299         assert( container.cbegin() != container.end() );
 300         assert( container.begin() != container.cend() );
 301       }
 302   };
 303
 304   template<typename _Tp,
 305            typename
 306     = typename std::iterator_traits<typename _Tp::iterator>::iterator_category>
 307     struct category_members : forward_members<_Tp>
 308     {
 309       category_members(_Tp& container)
 310         : forward_members<_Tp>(container)
 311       { };
 312     };
 313
 314   template<typename _Tp>
 315     struct category_members<_Tp, std::random_access_iterator_tag>
 316     : forward_members<_Tp>
 317     {
 318       category_members(_Tp& container)
 319         : forward_members<_Tp>(container)
 320       {
 321         // Make sure that even if rel_ops is injected there is no ambiguity
 322         // when comparing iterators.
 323         using namespace std::rel_ops;
 324
 325         assert( !(container.begin() < container.begin()) );
 326         assert( !(container.cbegin() < container.cbegin()) );
 327         assert( !(container.cbegin() < container.begin()) );
 328         assert( !(container.begin() < container.cbegin()) );
 329         assert( container.begin() <= container.begin() );
 330         assert( container.cbegin() <= container.cbegin() );
 331         assert( container.cbegin() <= container.begin() );
 332         assert( container.begin() <= container.cbegin() );
 333
 334         assert( !(container.begin() > container.begin()) );
 335         assert( !(container.cbegin() > container.cbegin()) );
 336         assert( !(container.cbegin() > container.begin()) );
 337         assert( !(container.begin() > container.cbegin()) );
 338         assert( container.begin() >= container.begin() );
 339         assert( container.cbegin() >= container.cbegin() );
 340         assert( container.cbegin() >= container.begin() );
 341         assert( container.begin() >= container.cbegin() );
 342
 343         assert( container.begin() - container.begin() == 0 );
 344         assert( container.cbegin() - container.cbegin() == 0 );
 345         assert( container.cbegin() - container.begin() == 0 );
 346         assert( container.begin() - container.cbegin() == 0 );
 347
 348         assert( container.begin() + 0 == container.begin() );
 349         assert( container.cbegin() + 0 == container.cbegin() );
 350         assert( 0 + container.begin() == container.begin() );
 351         assert( 0 + container.cbegin() == container.cbegin() );
 352         assert( container.begin() - 0 == container.begin() );
 353         assert( container.cbegin() - 0 == container.cbegin() );
 354       }
 355   };
 356
 357   template<typename _Tp>
 358     struct citerator
 359     {
 360       typedef _Tp                                       test_type;
 361       typedef traits<test_type>                         traits_type;
 362       typedef typename test_type::value_type            value_type;
 363
 364       static test_type _S_container;
 365
 366       // Unconditional.
 367       struct members : category_members<_Tp>
 368       {
 369         members() : category_members<_Tp>(_S_container)
 370         { }
 371       };
 372
 373       // Run test.
 374       citerator()
 375       {
 376         populate<test_type> p(_S_container);
 377         members m1;
 378         reverse_members<test_type> m2(_S_container);
 379       }
 380   };
 381
 382   template<typename _Tp>
 383   _Tp citerator<_Tp>::_S_container;
 384
 385   // DR 130 vs. C++98 vs. C++11.
 386   // Defined in testsuite_shared.cc.
 387   void
 388   erase_external(std::set<int>& s);
 389
 390   void
 391   erase_external(std::multiset<int>& s);
 392
 393   void
 394   erase_external(std::map<int, int>& s);
 395
 396   void
 397   erase_external(std::multimap<int, int>& s);
 398
 399   void
 400   erase_external_iterators(std::set<int>& s);
 401
 402   void
 403   erase_external_iterators(std::multiset<int>& s);
 404
 405   void
 406   erase_external_iterators(std::map<int, int>& s);
 407
 408   void
 409   erase_external_iterators(std::multimap<int, int>& s);
 410
 411 #if __cplusplus < 201103L
 412 # error "must be compiled with C++11 (or later)"
 413 #else
 414 template<typename _Tp>
 415   void
 416   linkage_check_cxx98_cxx11_erase(_Tp& container)
 417   {
 418     // Crashing when external reference and internal reference symbols are
 419     // equivalently mangled but have different size return types in C++98
 420     // and C++11 signatures.
 421     erase_external(container);          // C++98
 422     container.erase(container.begin()); // C++11
 423   }
 424
 425 template<typename _Tp>
 426   void
 427   linkage_check_cxx98_cxx11_erase_iterators(_Tp& container)
 428   {
 429     // Crashing when external reference and internal reference symbols are
 430     // equivalently mangled but have different size return types in C++98
 431     // and C++11 signatures.
 432     erase_external_iterators(container);// C++98
 433
 434     auto iter = container.begin();
 435     container.erase(iter, ++iter);      // C++11
 436   }
 437 #endif
 438
 439 } // namespace __gnu_test
 440
 441 #endif