test/support/debug_mode_helper.h

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef TEST_SUPPORT_DEBUG_MODE_HELPER_H
  11 #define TEST_SUPPORT_DEBUG_MODE_HELPER_H
  12
  13 #ifndef _LIBCPP_DEBUG
  14 #error _LIBCPP_DEBUG must be defined before including this header
  15 #endif
  16 #ifndef _LIBCPP_DEBUG_USE_EXCEPTIONS
  17 #error _LIBCPP_DEBUG_USE_EXCEPTIONS must be defined before including this header
  18 #endif
  19
  20 #include <ciso646>
  21 #ifndef _LIBCPP_VERSION
  22 #error This header may only be used for libc++ tests"
  23 #endif
  24
  25 #include <__debug>
  26 #include <utility>
  27 #include <cstddef>
  28 #include <cstdlib>
  29 #include <cassert>
  30
  31 #include "test_macros.h"
  32 #include "assert_checkpoint.h"
  33 #include "test_allocator.h"
  34
  35 // These test make use of 'if constexpr'.
  36 #if TEST_STD_VER <= 14
  37 #error This header may only be used in C++17 and greater
  38 #endif
  39 #ifdef TEST_HAS_NO_EXCEPTIONS
  40 #error These tests require exceptions
  41 #endif
  42
  43 #ifndef __cpp_if_constexpr
  44 #error These tests require if constexpr
  45 #endif
  46
  47 /// Assert that the specified expression throws a libc++ debug exception.
  48 #define CHECK_DEBUG_THROWS(...) assert((CheckDebugThrows( [&]() { __VA_ARGS__; } )))
  49
  50 template <class Func>
  51 inline bool CheckDebugThrows(Func&& func) {
  52   try {
  53     func();
  54   } catch (std::__libcpp_debug_exception const&) {
  55     return true;
  56   }
  57   return false;
  58 }
  59
  60 namespace IteratorDebugChecks {
  61
  62 enum ContainerType {
  63   CT_None,
  64   CT_String,
  65   CT_Vector,
  66   CT_VectorBool,
  67   CT_List,
  68   CT_Deque,
  69   CT_ForwardList,
  70   CT_Map,
  71   CT_Set,
  72   CT_MultiMap,
  73   CT_MultiSet,
  74   CT_UnorderedMap,
  75   CT_UnorderedSet,
  76   CT_UnorderedMultiMap,
  77   CT_UnorderedMultiSet
  78 };
  79
  80 constexpr bool isSequential(ContainerType CT) {
  81   return CT_Vector >= CT && CT_ForwardList <= CT;
  82 }
  83
  84 constexpr bool isAssociative(ContainerType CT) {
  85   return CT_Map >= CT && CT_MultiSet <= CT;
  86 }
  87
  88 constexpr bool isUnordered(ContainerType CT) {
  89   return CT_UnorderedMap >= CT && CT_UnorderedMultiSet <= CT;
  90 }
  91
  92 constexpr bool isSet(ContainerType CT) {
  93   return CT == CT_Set
  94       || CT == CT_MultiSet
  95       || CT == CT_UnorderedSet
  96       || CT == CT_UnorderedMultiSet;
  97 }
  98
  99 constexpr bool isMap(ContainerType CT) {
 100   return CT == CT_Map
 101       || CT == CT_MultiMap
 102       || CT == CT_UnorderedMap
 103       || CT == CT_UnorderedMultiMap;
 104 }
 105
 106 constexpr bool isMulti(ContainerType CT) {
 107   return CT == CT_MultiMap
 108       || CT == CT_MultiSet
 109       || CT == CT_UnorderedMultiMap
 110       || CT == CT_UnorderedMultiSet;
 111 }
 112
 113 template <class Container, class ValueType = typename Container::value_type>
 114 struct ContainerDebugHelper {
 115   static_assert(std::is_constructible<ValueType, int>::value,
 116                 "must be constructible from int");
 117
 118   static ValueType makeValueType(int val = 0, int = 0) {
 119     return ValueType(val);
 120   }
 121 };
 122
 123 template <class Container>
 124 struct ContainerDebugHelper<Container, char> {
 125   static char makeValueType(int = 0, int = 0) {
 126     return 'A';
 127   }
 128 };
 129
 130 template <class Container, class Key, class Value>
 131 struct ContainerDebugHelper<Container, std::pair<const Key, Value> > {
 132   using ValueType = std::pair<const Key, Value>;
 133   static_assert(std::is_constructible<Key, int>::value,
 134                 "must be constructible from int");
 135   static_assert(std::is_constructible<Value, int>::value,
 136                 "must be constructible from int");
 137
 138   static ValueType makeValueType(int key = 0, int val = 0) {
 139     return ValueType(key, val);
 140   }
 141 };
 142
 143 template <class Container, ContainerType CT,
 144     class Helper = ContainerDebugHelper<Container> >
 145 struct BasicContainerChecks {
 146   using value_type = typename Container::value_type;
 147   using iterator = typename Container::iterator;
 148   using const_iterator = typename Container::const_iterator;
 149   using allocator_type = typename Container::allocator_type;
 150   using traits = std::iterator_traits<iterator>;
 151   using category = typename traits::iterator_category;
 152
 153   static_assert(std::is_same<test_allocator<value_type>, allocator_type>::value,
 154                 "the container must use a test allocator");
 155
 156   static constexpr bool IsBiDir =
 157       std::is_convertible<category, std::bidirectional_iterator_tag>::value;
 158
 159 public:
 160   static void run() {
 161     run_iterator_tests();
 162     run_container_tests();
 163     run_allocator_aware_tests();
 164   }
 165
 166   static void run_iterator_tests() {
 167     try {
 168       TestNullIterators<iterator>();
 169       TestNullIterators<const_iterator>();
 170       if constexpr (IsBiDir) { DecrementBegin(); }
 171       IncrementEnd();
 172       DerefEndIterator();
 173     } catch (...) {
 174       assert(false && "uncaught debug exception");
 175     }
 176   }
 177
 178   static void run_container_tests() {
 179     try {
 180       CopyInvalidatesIterators();
 181       MoveInvalidatesIterators();
 182       if constexpr (CT != CT_ForwardList) {
 183           EraseIter();
 184           EraseIterIter();
 185       }
 186     } catch (...) {
 187       assert(false && "uncaught debug exception");
 188     }
 189   }
 190
 191   static void run_allocator_aware_tests() {
 192     try {
 193       SwapNonEqualAllocators();
 194       if constexpr (CT != CT_ForwardList ) {
 195           // FIXME: This should work for both forward_list and string
 196           SwapInvalidatesIterators();
 197       }
 198     } catch (...) {
 199       assert(false && "uncaught debug exception");
 200     }
 201   }
 202
 203   static Container makeContainer(int size, allocator_type A = allocator_type()) {
 204     Container C(A);
 205     if constexpr (CT == CT_ForwardList) {
 206       for (int i = 0; i < size; ++i)
 207         C.insert_after(C.before_begin(), Helper::makeValueType(i));
 208     } else {
 209       for (int i = 0; i < size; ++i)
 210         C.insert(C.end(), Helper::makeValueType(i));
 211       assert(C.size() == static_cast<std::size_t>(size));
 212     }
 213     return C;
 214   }
 215
 216   static value_type makeValueType(int value) {
 217     return Helper::makeValueType(value);
 218   }
 219
 220 private:
 221   // Iterator tests
 222   template <class Iter>
 223   static void TestNullIterators() {
 224     CHECKPOINT("testing null iterator");
 225     Iter it;
 226     CHECK_DEBUG_THROWS( ++it );
 227     CHECK_DEBUG_THROWS( it++ );
 228     CHECK_DEBUG_THROWS( *it );
 229     if constexpr (CT != CT_VectorBool) {
 230       CHECK_DEBUG_THROWS( it.operator->() );
 231     }
 232     if constexpr (IsBiDir) {
 233       CHECK_DEBUG_THROWS( --it );
 234       CHECK_DEBUG_THROWS( it-- );
 235     }
 236   }
 237
 238   static void DecrementBegin() {
 239     CHECKPOINT("testing decrement on begin");
 240     Container C = makeContainer(1);
 241     iterator i = C.end();
 242     const_iterator ci = C.cend();
 243     --i;
 244     --ci;
 245     assert(i == C.begin());
 246     CHECK_DEBUG_THROWS( --i );
 247     CHECK_DEBUG_THROWS( i-- );
 248     CHECK_DEBUG_THROWS( --ci );
 249     CHECK_DEBUG_THROWS( ci-- );
 250   }
 251
 252   static void IncrementEnd() {
 253     CHECKPOINT("testing increment on end");
 254     Container C = makeContainer(1);
 255     iterator i = C.begin();
 256     const_iterator ci = C.begin();
 257     ++i;
 258     ++ci;
 259     assert(i == C.end());
 260     CHECK_DEBUG_THROWS( ++i );
 261     CHECK_DEBUG_THROWS( i++ );
 262     CHECK_DEBUG_THROWS( ++ci );
 263     CHECK_DEBUG_THROWS( ci++ );
 264   }
 265
 266   static void DerefEndIterator() {
 267     CHECKPOINT("testing deref end iterator");
 268     Container C = makeContainer(1);
 269     iterator i = C.begin();
 270     const_iterator ci = C.cbegin();
 271     (void)*i; (void)*ci;
 272     if constexpr (CT != CT_VectorBool) {
 273       i.operator->();
 274       ci.operator->();
 275     }
 276     ++i; ++ci;
 277     assert(i == C.end());
 278     CHECK_DEBUG_THROWS( *i );
 279     CHECK_DEBUG_THROWS( *ci );
 280     if constexpr (CT != CT_VectorBool) {
 281       CHECK_DEBUG_THROWS( i.operator->() );
 282       CHECK_DEBUG_THROWS( ci.operator->() );
 283     }
 284   }
 285
 286   // Container tests
 287   static void CopyInvalidatesIterators() {
 288     CHECKPOINT("copy invalidates iterators");
 289     Container C1 = makeContainer(3);
 290     iterator i = C1.begin();
 291     Container C2 = C1;
 292     if constexpr (CT == CT_ForwardList) {
 293       iterator i_next = i;
 294       ++i_next;
 295       (void)*i_next;
 296       CHECK_DEBUG_THROWS( C2.erase_after(i) );
 297       C1.erase_after(i);
 298       CHECK_DEBUG_THROWS( *i_next );
 299     } else {
 300       CHECK_DEBUG_THROWS( C2.erase(i) );
 301       (void)*i;
 302       C1.erase(i);
 303       CHECK_DEBUG_THROWS( *i );
 304     }
 305   }
 306
 307   static void MoveInvalidatesIterators() {
 308     CHECKPOINT("copy move invalidates iterators");
 309     Container C1 = makeContainer(3);
 310     iterator i = C1.begin();
 311     Container C2 = std::move(C1);
 312     (void) *i;
 313     if constexpr (CT == CT_ForwardList) {
 314       CHECK_DEBUG_THROWS( C1.erase_after(i) );
 315       C2.erase_after(i);
 316     } else {
 317       CHECK_DEBUG_THROWS( C1.erase(i) );
 318       C2.erase(i);
 319       CHECK_DEBUG_THROWS(*i);
 320     }
 321   }
 322
 323   static void EraseIter() {
 324     CHECKPOINT("testing erase invalidation");
 325     Container C1 = makeContainer(2);
 326     iterator it1 = C1.begin();
 327     iterator it1_next = it1;
 328     ++it1_next;
 329     Container C2 = C1;
 330     CHECK_DEBUG_THROWS( C2.erase(it1) ); // wrong container
 331     CHECK_DEBUG_THROWS( C2.erase(C2.end()) ); // erase with end
 332     C1.erase(it1_next);
 333     CHECK_DEBUG_THROWS( C1.erase(it1_next) ); // invalidated iterator
 334     C1.erase(it1);
 335     CHECK_DEBUG_THROWS( C1.erase(it1) ); // invalidated iterator
 336   }
 337
 338   static void EraseIterIter() {
 339     CHECKPOINT("testing erase iter iter invalidation");
 340     Container C1 = makeContainer(2);
 341     iterator it1 = C1.begin();
 342     iterator it1_next = it1;
 343     ++it1_next;
 344     Container C2 = C1;
 345     iterator it2 = C2.begin();
 346     iterator it2_next = it2;
 347     ++it2_next;
 348     CHECK_DEBUG_THROWS( C2.erase(it1, it1_next) ); // begin from wrong container
 349     CHECK_DEBUG_THROWS( C2.erase(it1, it2_next) ); // end   from wrong container
 350     CHECK_DEBUG_THROWS( C2.erase(it2, it1_next) ); // both  from wrong container
 351     C2.erase(it2, it2_next);
 352   }
 353
 354   // Allocator aware tests
 355   static void SwapInvalidatesIterators() {
 356     CHECKPOINT("testing swap invalidates iterators");
 357     Container C1 = makeContainer(3);
 358     Container C2 = makeContainer(3);
 359     iterator it1 = C1.begin();
 360     iterator it2 = C2.begin();
 361     swap(C1, C2);
 362     CHECK_DEBUG_THROWS( C1.erase(it1) );
 363     if (CT == CT_String) {
 364       CHECK_DEBUG_THROWS(C1.erase(it2));
 365     } else
 366       C1.erase(it2);
 367     //C2.erase(it1);
 368     CHECK_DEBUG_THROWS( C1.erase(it1) );
 369   }
 370
 371   static void SwapNonEqualAllocators() {
 372     CHECKPOINT("testing swap with non-equal allocators");
 373     Container C1 = makeContainer(3, allocator_type(1));
 374     Container C2 = makeContainer(1, allocator_type(2));
 375     Container C3 = makeContainer(2, allocator_type(2));
 376     swap(C2, C3);
 377     CHECK_DEBUG_THROWS( swap(C1, C2) );
 378   }
 379
 380 private:
 381   BasicContainerChecks() = delete;
 382 };
 383
 384 } // namespace IteratorDebugChecks
 385
 386 #endif // TEST_SUPPORT_DEBUG_MODE_HELPER_H