• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
387