+2016-10-17 Paolo Carlini <paolo.carlini@oracle.com>
+
+ * testsuite/unordered_map/insert/57619.C: Rename to 57619.cc.
+ * testsuite/23_containers/unordered_multimap/insert/57619.C: Likewise.
+
+2016-10-17 Paolo Carlini <paolo.carlini@oracle.com>
+
+ * testsuite/array/capacity/empty.cc: Remove 'test' variables.
+ * testsuite/array/capacity/max_size.cc: Likewise.
+ * testsuite/array/capacity/size.cc: Likewise.
+ * testsuite/array/comparison_operators/equal.cc: Likewise.
+ * testsuite/array/comparison_operators/greater.cc: Likewise.
+ * testsuite/array/comparison_operators/greater_or_equal.cc: Likewise.
+ * testsuite/array/comparison_operators/less.cc: Likewise.
+ * testsuite/array/comparison_operators/less_or_equal.cc: Likewise.
+ * testsuite/array/comparison_operators/not_equal.cc: Likewise.
+ * testsuite/array/element_access/54388.cc: Likewise.
+ * testsuite/array/element_access/at_out_of_range.cc: Likewise.
+ * testsuite/array/element_access/back.cc: Likewise.
+ * testsuite/array/element_access/data.cc: Likewise.
+ * testsuite/array/element_access/front.cc: Likewise.
+ * testsuite/array/iterators/end_is_one_past.cc: Likewise.
+ * testsuite/array/requirements/contiguous.cc: Likewise.
+ * testsuite/array/requirements/fill.cc: Likewise.
+ * testsuite/array/requirements/member_swap.cc: Likewise.
+ * testsuite/array/requirements/zero_sized_arrays.cc: Likewise.
+ * testsuite/array/specialized_algorithms/swap.cc: Likewise.
+ * testsuite/array/tuple_interface/tuple_element.cc: Likewise.
+ * testsuite/array/tuple_interface/tuple_element_cpp14.cc: Likewise.
+ * testsuite/array/tuple_interface/tuple_size.cc: Likewise.
+ * testsuite/bitset/all/1.cc: Likewise.
+ * testsuite/bitset/cons/1.cc: Likewise.
+ * testsuite/bitset/cons/16020.cc: Likewise.
+ * testsuite/bitset/cons/2.cc: Likewise.
+ * testsuite/bitset/cons/3.cc: Likewise.
+ * testsuite/bitset/cons/50268.cc: Likewise.
+ * testsuite/bitset/cons/6282.cc: Likewise.
+ * testsuite/bitset/cons/dr1325-2.cc: Likewise.
+ * testsuite/bitset/cons/dr396.cc: Likewise.
+ * testsuite/bitset/ext/15361.cc: Likewise.
+ * testsuite/bitset/input/1.cc: Likewise.
+ * testsuite/bitset/operations/1.cc: Likewise.
+ * testsuite/bitset/operations/13838.cc: Likewise.
+ * testsuite/bitset/operations/2.cc: Likewise.
+ * testsuite/bitset/test/1.cc: Likewise.
+ * testsuite/bitset/to_string/1.cc: Likewise.
+ * testsuite/bitset/to_string/dr396.cc: Likewise.
+ * testsuite/bitset/to_ullong/1.cc: Likewise.
+ * testsuite/bitset/to_ulong/1.cc: Likewise.
+ * testsuite/deque/allocator/copy.cc: Likewise.
+ * testsuite/deque/allocator/copy_assign.cc: Likewise.
+ * testsuite/deque/allocator/ext_ptr.cc: Likewise.
+ * testsuite/deque/allocator/minimal.cc: Likewise.
+ * testsuite/deque/allocator/move.cc: Likewise.
+ * testsuite/deque/allocator/move_assign.cc: Likewise.
+ * testsuite/deque/allocator/swap.cc: Likewise.
+ * testsuite/deque/capacity/29134-2.cc: Likewise.
+ * testsuite/deque/capacity/29134.cc: Likewise.
+ * testsuite/deque/capacity/moveable.cc: Likewise.
+ * testsuite/deque/capacity/resize_size.cc: Likewise.
+ * testsuite/deque/capacity/shrink_to_fit.cc: Likewise.
+ * testsuite/deque/cons/1.cc: Likewise.
+ * testsuite/deque/cons/2.cc: Likewise.
+ * testsuite/deque/cons/assign/1.cc: Likewise.
+ * testsuite/deque/cons/cons_size.cc: Likewise.
+ * testsuite/deque/cons/moveable.cc: Likewise.
+ * testsuite/deque/modifiers/erase/1.cc: Likewise.
+ * testsuite/deque/modifiers/erase/2.cc: Likewise.
+ * testsuite/deque/modifiers/erase/3.cc: Likewise.
+ * testsuite/deque/modifiers/erase/moveable.cc: Likewise.
+ * testsuite/deque/modifiers/moveable.cc: Likewise.
+ * testsuite/deque/modifiers/push_back/49836.cc: Likewise.
+ * testsuite/deque/modifiers/push_front/49836.cc: Likewise.
+ * testsuite/deque/modifiers/swap/1.cc: Likewise.
+ * testsuite/deque/modifiers/swap/2.cc: Likewise.
+ * testsuite/deque/modifiers/swap/3.cc: Likewise.
+ * testsuite/deque/operators/1.cc: Likewise.
+ * testsuite/deque/operators/2.cc: Likewise.
+ * testsuite/forward_list/allocator/copy.cc: Likewise.
+ * testsuite/forward_list/allocator/copy_assign.cc: Likewise.
+ * testsuite/forward_list/allocator/ext_ptr.cc: Likewise.
+ * testsuite/forward_list/allocator/minimal.cc: Likewise.
+ * testsuite/forward_list/allocator/move.cc: Likewise.
+ * testsuite/forward_list/allocator/move_assign.cc: Likewise.
+ * testsuite/forward_list/allocator/swap.cc: Likewise.
+ * testsuite/forward_list/capacity/1.cc: Likewise.
+ * testsuite/forward_list/capacity/resize_size.cc: Likewise.
+ * testsuite/forward_list/comparable.cc: Likewise.
+ * testsuite/forward_list/cons/1.cc: Likewise.
+ * testsuite/forward_list/cons/2.cc: Likewise.
+ * testsuite/forward_list/cons/3.cc: Likewise.
+ * testsuite/forward_list/cons/4.cc: Likewise.
+ * testsuite/forward_list/cons/5.cc: Likewise.
+ * testsuite/forward_list/cons/6.cc: Likewise.
+ * testsuite/forward_list/cons/7.cc: Likewise.
+ * testsuite/forward_list/cons/8.cc: Likewise.
+ * testsuite/forward_list/cons/9.cc: Likewise.
+ * testsuite/forward_list/cons/cons_size.cc: Likewise.
+ * testsuite/forward_list/cons/moveable.cc: Likewise.
+ * testsuite/forward_list/debug/clear.cc: Likewise.
+ * testsuite/forward_list/debug/construct4_neg.cc: Likewise.
+ * testsuite/forward_list/debug/erase_after1_neg.cc: Likewise.
+ * testsuite/forward_list/debug/move_assign_neg.cc: Likewise.
+ * testsuite/forward_list/debug/move_constructor.cc: Likewise.
+ * testsuite/forward_list/debug/move_neg.cc: Likewise.
+ * testsuite/forward_list/debug/splice_after.cc: Likewise.
+ * testsuite/forward_list/debug/swap.cc: Likewise.
+ * testsuite/forward_list/modifiers/1.cc: Likewise.
+ * testsuite/forward_list/modifiers/2.cc: Likewise.
+ * testsuite/forward_list/modifiers/3.cc: Likewise.
+ * testsuite/forward_list/modifiers/4.cc: Likewise.
+ * testsuite/forward_list/modifiers/5.cc: Likewise.
+ * testsuite/forward_list/modifiers/6.cc: Likewise.
+ * testsuite/forward_list/operations/1.cc: Likewise.
+ * testsuite/forward_list/operations/2.cc: Likewise.
+ * testsuite/forward_list/operations/3.cc: Likewise.
+ * testsuite/forward_list/operations/4.cc: Likewise.
+ * testsuite/forward_list/operations/5.cc: Likewise.
+ * testsuite/forward_list/operations/6.cc: Likewise.
+ * testsuite/forward_list/operations/7.cc: Likewise.
+ * testsuite/forward_list/operations/remove_freed.cc: Likewise.
+ * testsuite/list/61347.cc: Likewise.
+ * testsuite/list/allocator/copy.cc: Likewise.
+ * testsuite/list/allocator/copy_assign.cc: Likewise.
+ * testsuite/list/allocator/minimal.cc: Likewise.
+ * testsuite/list/allocator/move.cc: Likewise.
+ * testsuite/list/allocator/move_assign.cc: Likewise.
+ * testsuite/list/allocator/swap.cc: Likewise.
+ * testsuite/list/capacity/1.h: Likewise.
+ * testsuite/list/capacity/29134.cc: Likewise.
+ * testsuite/list/capacity/resize_size.cc: Likewise.
+ * testsuite/list/cons/1.h: Likewise.
+ * testsuite/list/cons/2.h: Likewise.
+ * testsuite/list/cons/3.h: Likewise.
+ * testsuite/list/cons/4.h: Likewise.
+ * testsuite/list/cons/5.h: Likewise.
+ * testsuite/list/cons/6.h: Likewise.
+ * testsuite/list/cons/7.h: Likewise.
+ * testsuite/list/cons/8.h: Likewise.
+ * testsuite/list/cons/9.h: Likewise.
+ * testsuite/list/cons/cons_size.cc: Likewise.
+ * testsuite/list/cons/moveable.h: Likewise.
+ * testsuite/list/debug/invalidation/1.cc: Likewise.
+ * testsuite/list/debug/invalidation/2.cc: Likewise.
+ * testsuite/list/debug/invalidation/3.cc: Likewise.
+ * testsuite/list/debug/invalidation/4.cc: Likewise.
+ * testsuite/list/modifiers/1.h: Likewise.
+ * testsuite/list/modifiers/2.h: Likewise.
+ * testsuite/list/modifiers/3.h: Likewise.
+ * testsuite/list/modifiers/insert/25288.h: Likewise.
+ * testsuite/list/modifiers/swap/1.h: Likewise.
+ * testsuite/list/modifiers/swap/2.h: Likewise.
+ * testsuite/list/modifiers/swap/3.h: Likewise.
+ * testsuite/list/operations/1.h: Likewise.
+ * testsuite/list/operations/2.h: Likewise.
+ * testsuite/list/operations/3.h: Likewise.
+ * testsuite/list/operations/4.h: Likewise.
+ * testsuite/list/operations/42352.cc: Likewise.
+ * testsuite/map/allocator/copy.cc: Likewise.
+ * testsuite/map/allocator/copy_assign.cc: Likewise.
+ * testsuite/map/allocator/init-list.cc: Likewise.
+ * testsuite/map/allocator/minimal.cc: Likewise.
+ * testsuite/map/allocator/move.cc: Likewise.
+ * testsuite/map/allocator/move_assign.cc: Likewise.
+ * testsuite/map/allocator/swap.cc: Likewise.
+ * testsuite/map/capacity/29134.cc: Likewise.
+ * testsuite/map/cons/moveable.cc: Likewise.
+ * testsuite/map/debug/construct5_neg.cc: Likewise.
+ * testsuite/map/debug/move_assign_neg.cc: Likewise.
+ * testsuite/map/debug/move_neg.cc: Likewise.
+ * testsuite/map/element_access/1.cc: Likewise.
+ * testsuite/map/element_access/2.cc: Likewise.
+ * testsuite/map/element_access/39901.cc: Likewise.
+ * testsuite/map/init-list.cc: Likewise.
+ * testsuite/map/modifiers/dr130.cc: Likewise.
+ * testsuite/map/modifiers/emplace/1.cc: Likewise.
+ * testsuite/map/modifiers/extract.cc: Likewise.
+ * testsuite/map/modifiers/insert/1.cc: Likewise.
+ * testsuite/map/modifiers/insert/16813.cc: Likewise.
+ * testsuite/map/modifiers/insert/2.cc: Likewise.
+ * testsuite/map/modifiers/insert/3.cc: Likewise.
+ * testsuite/map/modifiers/insert/4.cc: Likewise.
+ * testsuite/map/modifiers/insert/5.cc: Likewise.
+ * testsuite/map/modifiers/insert_or_assign/1.cc: Likewise.
+ * testsuite/map/modifiers/merge.cc: Likewise.
+ * testsuite/map/modifiers/swap/1.cc: Likewise.
+ * testsuite/map/modifiers/swap/2.cc: Likewise.
+ * testsuite/map/modifiers/swap/3.cc: Likewise.
+ * testsuite/map/modifiers/try_emplace/1.cc: Likewise.
+ * testsuite/map/operations/1.cc: Likewise.
+ * testsuite/map/operations/count.cc: Likewise.
+ * testsuite/map/operators/1_neg.cc: Likewise.
+ * testsuite/map/operators/2.cc: Likewise.
+ * testsuite/multimap/allocator/copy.cc: Likewise.
+ * testsuite/multimap/allocator/copy_assign.cc: Likewise.
+ * testsuite/multimap/allocator/init-list.cc: Likewise.
+ * testsuite/multimap/allocator/minimal.cc: Likewise.
+ * testsuite/multimap/allocator/move.cc: Likewise.
+ * testsuite/multimap/allocator/move_assign.cc: Likewise.
+ * testsuite/multimap/allocator/swap.cc: Likewise.
+ * testsuite/multimap/capacity/29134.cc: Likewise.
+ * testsuite/multimap/cons/moveable.cc: Likewise.
+ * testsuite/multimap/debug/construct5_neg.cc: Likewise.
+ * testsuite/multimap/debug/move_assign_neg.cc: Likewise.
+ * testsuite/multimap/debug/move_neg.cc: Likewise.
+ * testsuite/multimap/init-list.cc: Likewise.
+ * testsuite/multimap/modifiers/dr130.cc: Likewise.
+ * testsuite/multimap/modifiers/emplace/1.cc: Likewise.
+ * testsuite/multimap/modifiers/extract.cc: Likewise.
+ * testsuite/multimap/modifiers/insert/1.cc: Likewise.
+ * testsuite/multimap/modifiers/insert/2.cc: Likewise.
+ * testsuite/multimap/modifiers/insert/22102.cc: Likewise.
+ * testsuite/multimap/modifiers/insert/3.cc: Likewise.
+ * testsuite/multimap/modifiers/insert/4.cc: Likewise.
+ * testsuite/multimap/modifiers/merge.cc: Likewise.
+ * testsuite/multimap/modifiers/swap/1.cc: Likewise.
+ * testsuite/multimap/modifiers/swap/2.cc: Likewise.
+ * testsuite/multimap/modifiers/swap/3.cc: Likewise.
+ * testsuite/multimap/operations/1.cc: Likewise.
+ * testsuite/multimap/operations/count.cc: Likewise.
+ * testsuite/multiset/allocator/copy.cc: Likewise.
+ * testsuite/multiset/allocator/copy_assign.cc: Likewise.
+ * testsuite/multiset/allocator/init-list.cc: Likewise.
+ * testsuite/multiset/allocator/minimal.cc: Likewise.
+ * testsuite/multiset/allocator/move.cc: Likewise.
+ * testsuite/multiset/allocator/move_assign.cc: Likewise.
+ * testsuite/multiset/allocator/swap.cc: Likewise.
+ * testsuite/multiset/capacity/29134.cc: Likewise.
+ * testsuite/multiset/cons/moveable.cc: Likewise.
+ * testsuite/multiset/debug/construct5_neg.cc: Likewise.
+ * testsuite/multiset/debug/invalidation/2.cc: Likewise.
+ * testsuite/multiset/debug/move_assign_neg.cc: Likewise.
+ * testsuite/multiset/debug/move_neg.cc: Likewise.
+ * testsuite/multiset/init-list.cc: Likewise.
+ * testsuite/multiset/modifiers/dr130.cc: Likewise.
+ * testsuite/multiset/modifiers/emplace/1.cc: Likewise.
+ * testsuite/multiset/modifiers/extract.cc: Likewise.
+ * testsuite/multiset/modifiers/insert/1.cc: Likewise.
+ * testsuite/multiset/modifiers/insert/2.cc: Likewise.
+ * testsuite/multiset/modifiers/insert/22102.cc: Likewise.
+ * testsuite/multiset/modifiers/insert/3.cc: Likewise.
+ * testsuite/multiset/modifiers/insert/4.cc: Likewise.
+ * testsuite/multiset/modifiers/merge.cc: Likewise.
+ * testsuite/multiset/modifiers/swap/1.cc: Likewise.
+ * testsuite/multiset/modifiers/swap/2.cc: Likewise.
+ * testsuite/multiset/modifiers/swap/3.cc: Likewise.
+ * testsuite/multiset/operations/1.cc: Likewise.
+ * testsuite/multiset/operations/count.cc: Likewise.
+ * testsuite/priority_queue/moveable.cc: Likewise.
+ * testsuite/queue/moveable.cc: Likewise.
+ * testsuite/set/allocator/copy.cc: Likewise.
+ * testsuite/set/allocator/copy_assign.cc: Likewise.
+ * testsuite/set/allocator/init-list.cc: Likewise.
+ * testsuite/set/allocator/minimal.cc: Likewise.
+ * testsuite/set/allocator/move.cc: Likewise.
+ * testsuite/set/allocator/move_assign.cc: Likewise.
+ * testsuite/set/allocator/swap.cc: Likewise.
+ * testsuite/set/capacity/29134.cc: Likewise.
+ * testsuite/set/cons/moveable.cc: Likewise.
+ * testsuite/set/debug/construct5_neg.cc: Likewise.
+ * testsuite/set/debug/invalidation/2.cc: Likewise.
+ * testsuite/set/debug/move_assign_neg.cc: Likewise.
+ * testsuite/set/debug/move_neg.cc: Likewise.
+ * testsuite/set/init-list.cc: Likewise.
+ * testsuite/set/modifiers/17948.cc: Likewise.
+ * testsuite/set/modifiers/dr130.cc: Likewise.
+ * testsuite/set/modifiers/emplace/1.cc: Likewise.
+ * testsuite/set/modifiers/extract.cc: Likewise.
+ * testsuite/set/modifiers/insert/1.cc: Likewise.
+ * testsuite/set/modifiers/insert/2.cc: Likewise.
+ * testsuite/set/modifiers/insert/3.cc: Likewise.
+ * testsuite/set/modifiers/merge.cc: Likewise.
+ * testsuite/set/modifiers/swap/1.cc: Likewise.
+ * testsuite/set/modifiers/swap/2.cc: Likewise.
+ * testsuite/set/modifiers/swap/3.cc: Likewise.
+ * testsuite/set/operations/1.cc: Likewise.
+ * testsuite/set/operations/count.cc: Likewise.
+ * testsuite/set/operators/1_neg.cc: Likewise.
+ * testsuite/unordered_map/allocator/copy.cc: Likewise.
+ * testsuite/unordered_map/allocator/copy_assign.cc: Likewise.
+ * testsuite/unordered_map/allocator/minimal.cc: Likewise.
+ * testsuite/unordered_map/allocator/move.cc: Likewise.
+ * testsuite/unordered_map/allocator/move_assign.cc: Likewise.
+ * testsuite/unordered_map/allocator/swap.cc: Likewise.
+ * testsuite/unordered_map/cons/moveable.cc: Likewise.
+ * testsuite/unordered_map/debug/construct5_neg.cc: Likewise.
+ * testsuite/unordered_map/debug/move_assign_neg.cc: Likewise.
+ * testsuite/unordered_map/debug/move_neg.cc: Likewise.
+ * testsuite/unordered_map/dr761.cc: Likewise.
+ * testsuite/unordered_map/erase/1.cc: Likewise.
+ * testsuite/unordered_map/erase/24061-map.cc: Likewise.
+ * testsuite/unordered_map/erase/54276.cc: Likewise.
+ * testsuite/unordered_map/hash_policy/dr1189.cc: Likewise.
+ * testsuite/unordered_map/init-list.cc: Likewise.
+ * testsuite/unordered_map/insert/24061-map.cc: Likewise.
+ * testsuite/unordered_map/insert/57619.C: Likewise.
+ * testsuite/unordered_map/insert/array_syntax.cc: Likewise.
+ * testsuite/unordered_map/insert/array_syntax_move.cc: Likewise.
+ * testsuite/unordered_map/insert/map_range.cc: Likewise.
+ * testsuite/unordered_map/insert/map_single.cc: Likewise.
+ * testsuite/unordered_map/insert/map_single_move-1.cc: Likewise.
+ * testsuite/unordered_map/insert/map_single_move-2.cc: Likewise.
+ * testsuite/unordered_map/modifiers/61667.cc: Likewise.
+ * testsuite/unordered_map/modifiers/emplace.cc: Likewise.
+ * testsuite/unordered_map/modifiers/extract.cc: Likewise.
+ * testsuite/unordered_map/modifiers/insert_or_assign.cc: Likewise.
+ * testsuite/unordered_map/modifiers/merge.cc: Likewise.
+ * testsuite/unordered_map/modifiers/reserve.cc: Likewise.
+ * testsuite/unordered_map/modifiers/try_emplace.cc: Likewise.
+ * testsuite/unordered_map/operations/count.cc: Likewise.
+ * testsuite/unordered_map/operators/1.cc: Likewise.
+ * testsuite/unordered_map/operators/2.cc: Likewise.
+ * testsuite/unordered_multimap/allocator/copy.cc: Likewise.
+ * testsuite/unordered_multimap/allocator/copy_assign.cc: Likewise.
+ * testsuite/unordered_multimap/allocator/minimal.cc: Likewise.
+ * testsuite/unordered_multimap/allocator/move.cc: Likewise.
+ * testsuite/unordered_multimap/allocator/move_assign.cc: Likewise.
+ * testsuite/unordered_multimap/allocator/swap.cc: Likewise.
+ * testsuite/unordered_multimap/cons/moveable.cc: Likewise.
+ * testsuite/unordered_multimap/debug/construct5_neg.cc: Likewise.
+ * testsuite/unordered_multimap/debug/move_assign_neg.cc: Likewise.
+ * testsuite/unordered_multimap/debug/move_neg.cc: Likewise.
+ * testsuite/unordered_multimap/erase/1.cc: Likewise.
+ * testsuite/unordered_multimap/erase/2.cc: Likewise.
+ * testsuite/unordered_multimap/erase/24061-multimap.cc: Likewise.
+ * testsuite/unordered_multimap/erase/51845-multimap.cc: Likewise.
+ * testsuite/unordered_multimap/erase/54276.cc: Likewise.
+ * testsuite/unordered_multimap/hash_policy/dr1189.cc: Likewise.
+ * testsuite/unordered_multimap/init-list.cc: Likewise.
+ * testsuite/unordered_multimap/insert/24061-multimap.cc: Likewise.
+ * testsuite/unordered_multimap/insert/51866.cc: Likewise.
+ * testsuite/unordered_multimap/insert/52476.cc: Likewise.
+ * testsuite/unordered_multimap/insert/53115.cc: Likewise.
+ * testsuite/unordered_multimap/insert/57619.C: Likewise.
+ * testsuite/unordered_multimap/insert/hint.cc: Likewise.
+ * testsuite/unordered_multimap/insert/multimap_range.cc: Likewise.
+ * testsuite/unordered_multimap/insert/multimap_single.cc: Likewise.
+ * testsuite/unordered_multimap/insert/multimap_single_move-1.cc:
+ Likewise.
+ * testsuite/unordered_multimap/insert/multimap_single_move-2.cc:
+ Likewise.
+ * testsuite/unordered_multimap/modifiers/emplace.cc: Likewise.
+ * testsuite/unordered_multimap/modifiers/extract.cc: Likewise.
+ * testsuite/unordered_multimap/modifiers/merge.cc: Likewise.
+ * testsuite/unordered_multimap/modifiers/reserve.cc: Likewise.
+ * testsuite/unordered_multimap/operations/count.cc: Likewise.
+ * testsuite/unordered_multimap/operators/1.cc: Likewise.
+ * testsuite/unordered_multimap/operators/2.cc: Likewise.
+ * testsuite/unordered_multiset/allocator/copy.cc: Likewise.
+ * testsuite/unordered_multiset/allocator/copy_assign.cc: Likewise.
+ * testsuite/unordered_multiset/allocator/minimal.cc: Likewise.
+ * testsuite/unordered_multiset/allocator/move.cc: Likewise.
+ * testsuite/unordered_multiset/allocator/move_assign.cc: Likewise.
+ * testsuite/unordered_multiset/allocator/swap.cc: Likewise.
+ * testsuite/unordered_multiset/cons/copy.cc: Likewise.
+ * testsuite/unordered_multiset/cons/moveable.cc: Likewise.
+ * testsuite/unordered_multiset/debug/construct5_neg.cc: Likewise.
+ * testsuite/unordered_multiset/debug/move_assign_neg.cc: Likewise.
+ * testsuite/unordered_multiset/debug/move_neg.cc: Likewise.
+ * testsuite/unordered_multiset/erase/1.cc: Likewise.
+ * testsuite/unordered_multiset/erase/2.cc: Likewise.
+ * testsuite/unordered_multiset/erase/24061-multiset.cc: Likewise.
+ * testsuite/unordered_multiset/hash_policy/dr1189.cc: Likewise.
+ * testsuite/unordered_multiset/init-list.cc: Likewise.
+ * testsuite/unordered_multiset/insert/24061-multiset.cc: Likewise.
+ * testsuite/unordered_multiset/insert/51866.cc: Likewise.
+ * testsuite/unordered_multiset/insert/52476.cc: Likewise.
+ * testsuite/unordered_multiset/insert/53115.cc: Likewise.
+ * testsuite/unordered_multiset/insert/hash_policy.cc: Likewise.
+ * testsuite/unordered_multiset/insert/multiset_range.cc: Likewise.
+ * testsuite/unordered_multiset/insert/multiset_single.cc: Likewise.
+ * testsuite/unordered_multiset/insert/multiset_single_move.cc: Likewise.
+ * testsuite/unordered_multiset/modifiers/emplace.cc: Likewise.
+ * testsuite/unordered_multiset/modifiers/extract.cc: Likewise.
+ * testsuite/unordered_multiset/modifiers/merge.cc: Likewise.
+ * testsuite/unordered_multiset/modifiers/reserve.cc: Likewise.
+ * testsuite/unordered_multiset/operations/count.cc: Likewise.
+ * testsuite/unordered_multiset/operators/1.cc: Likewise.
+ * testsuite/unordered_set/allocator/copy.cc: Likewise.
+ * testsuite/unordered_set/allocator/copy_assign.cc: Likewise.
+ * testsuite/unordered_set/allocator/ext_ptr.cc: Likewise.
+ * testsuite/unordered_set/allocator/minimal.cc: Likewise.
+ * testsuite/unordered_set/allocator/move.cc: Likewise.
+ * testsuite/unordered_set/allocator/move_assign.cc: Likewise.
+ * testsuite/unordered_set/allocator/swap.cc: Likewise.
+ * testsuite/unordered_set/buckets/swap.cc: Likewise.
+ * testsuite/unordered_set/cons/moveable.cc: Likewise.
+ * testsuite/unordered_set/debug/construct5_neg.cc: Likewise.
+ * testsuite/unordered_set/debug/debug_functions.cc: Likewise.
+ * testsuite/unordered_set/debug/move_assign_neg.cc: Likewise.
+ * testsuite/unordered_set/debug/move_neg.cc: Likewise.
+ * testsuite/unordered_set/erase/1.cc: Likewise.
+ * testsuite/unordered_set/erase/24061-set.cc: Likewise.
+ * testsuite/unordered_set/hash_policy/26132.cc: Likewise.
+ * testsuite/unordered_set/hash_policy/71181.cc: Likewise.
+ * testsuite/unordered_set/hash_policy/dr1189.cc: Likewise.
+ * testsuite/unordered_set/hash_policy/load_factor.cc: Likewise.
+ * testsuite/unordered_set/hash_policy/power2_rehash.cc: Likewise.
+ * testsuite/unordered_set/hash_policy/prime_rehash.cc: Likewise.
+ * testsuite/unordered_set/hash_policy/rehash.cc: Likewise.
+ * testsuite/unordered_set/init-list.cc: Likewise.
+ * testsuite/unordered_set/insert/24061-set.cc: Likewise.
+ * testsuite/unordered_set/insert/hash_policy.cc: Likewise.
+ * testsuite/unordered_set/insert/move_range.cc: Likewise.
+ * testsuite/unordered_set/insert/set_range.cc: Likewise.
+ * testsuite/unordered_set/insert/set_single.cc: Likewise.
+ * testsuite/unordered_set/insert/set_single_move.cc: Likewise.
+ * testsuite/unordered_set/max_load_factor/robustness.cc: Likewise.
+ * testsuite/unordered_set/modifiers/emplace.cc: Likewise.
+ * testsuite/unordered_set/modifiers/extract.cc: Likewise.
+ * testsuite/unordered_set/modifiers/merge.cc: Likewise.
+ * testsuite/unordered_set/modifiers/reserve.cc: Likewise.
+ * testsuite/unordered_set/modifiers/swap.cc: Likewise.
+ * testsuite/unordered_set/operations/count.cc: Likewise.
+ * testsuite/unordered_set/operators/1.cc: Likewise.
+ * testsuite/vector/allocator/copy.cc: Likewise.
+ * testsuite/vector/allocator/copy_assign.cc: Likewise.
+ * testsuite/vector/allocator/ext_ptr.cc: Likewise.
+ * testsuite/vector/allocator/minimal.cc: Likewise.
+ * testsuite/vector/allocator/move.cc: Likewise.
+ * testsuite/vector/allocator/move_assign.cc: Likewise.
+ * testsuite/vector/allocator/swap.cc: Likewise.
+ * testsuite/vector/bool/6886.cc: Likewise.
+ * testsuite/vector/bool/72847.cc: Likewise.
+ * testsuite/vector/bool/allocator/copy.cc: Likewise.
+ * testsuite/vector/bool/allocator/copy_assign.cc: Likewise.
+ * testsuite/vector/bool/allocator/ext_ptr.cc: Likewise.
+ * testsuite/vector/bool/allocator/move.cc: Likewise.
+ * testsuite/vector/bool/allocator/move_assign.cc: Likewise.
+ * testsuite/vector/bool/allocator/swap.cc: Likewise.
+ * testsuite/vector/bool/capacity/1.cc: Likewise.
+ * testsuite/vector/bool/capacity/29134.cc: Likewise.
+ * testsuite/vector/bool/capacity/shrink_to_fit.cc: Likewise.
+ * testsuite/vector/bool/cons/1.cc: Likewise.
+ * testsuite/vector/bool/cons/2.cc: Likewise.
+ * testsuite/vector/bool/modifiers/erase/1.cc: Likewise.
+ * testsuite/vector/bool/modifiers/insert/1.cc: Likewise.
+ * testsuite/vector/bool/modifiers/insert/31370.cc: Likewise.
+ * testsuite/vector/bool/modifiers/swap/1.cc: Likewise.
+ * testsuite/vector/bool/modifiers/swap/2.cc: Likewise.
+ * testsuite/vector/bool/swap.cc: Likewise.
+ * testsuite/vector/capacity/1.cc: Likewise.
+ * testsuite/vector/capacity/2.cc: Likewise.
+ * testsuite/vector/capacity/29134-2.cc: Likewise.
+ * testsuite/vector/capacity/29134.cc: Likewise.
+ * testsuite/vector/capacity/44190.cc: Likewise.
+ * testsuite/vector/capacity/8230.cc: Likewise.
+ * testsuite/vector/capacity/reserve/moveable.cc: Likewise.
+ * testsuite/vector/capacity/reserve/moveable2.cc: Likewise.
+ * testsuite/vector/capacity/resize/1.cc: Likewise.
+ * testsuite/vector/capacity/resize/moveable.cc: Likewise.
+ * testsuite/vector/capacity/resize/moveable2.cc: Likewise.
+ * testsuite/vector/capacity/resize/resize_size.cc: Likewise.
+ * testsuite/vector/capacity/shrink_to_fit.cc: Likewise.
+ * testsuite/vector/capacity/shrink_to_fit2.cc: Likewise.
+ * testsuite/vector/cons/3.cc: Likewise.
+ * testsuite/vector/cons/4.cc: Likewise.
+ * testsuite/vector/cons/cons_size.cc: Likewise.
+ * testsuite/vector/cons/moveable.cc: Likewise.
+ * testsuite/vector/data_access/1.cc: Likewise.
+ * testsuite/vector/debug/debug_functions.cc: Likewise.
+ * testsuite/vector/debug/move_assign_neg.cc: Likewise.
+ * testsuite/vector/debug/move_neg.cc: Likewise.
+ * testsuite/vector/debug/multithreaded_swap.cc: Likewise.
+ * testsuite/vector/element_access/1.cc: Likewise.
+ * testsuite/vector/ext_pointer/citerators.cc: Likewise.
+ * testsuite/vector/ext_pointer/data_access.cc: Likewise.
+ * testsuite/vector/ext_pointer/modifiers/element.cc: Likewise.
+ * testsuite/vector/ext_pointer/modifiers/erase.cc: Likewise.
+ * testsuite/vector/ext_pointer/modifiers/insert.cc: Likewise.
+ * testsuite/vector/ext_pointer/resize.cc: Likewise.
+ * testsuite/vector/modifiers/1.cc: Likewise.
+ * testsuite/vector/modifiers/2.cc: Likewise.
+ * testsuite/vector/modifiers/emplace/self_emplace.cc: Likewise.
+ * testsuite/vector/modifiers/erase/1.cc: Likewise.
+ * testsuite/vector/modifiers/erase/moveable.cc: Likewise.
+ * testsuite/vector/modifiers/insert/1.cc: Likewise.
+ * testsuite/vector/modifiers/insert/self_insert.cc: Likewise.
+ * testsuite/vector/modifiers/moveable.cc: Likewise.
+ * testsuite/vector/modifiers/moveable2.cc: Likewise.
+ * testsuite/vector/modifiers/push_back/49836.cc: Likewise.
+ * testsuite/vector/modifiers/swap/1.cc: Likewise.
+ * testsuite/vector/modifiers/swap/2.cc: Likewise.
+ * testsuite/vector/modifiers/swap/3.cc: Likewise.
+ * testsuite/vector/zero_sized_allocations.cc: Likewise.
+
2016-10-17 Jonathan Wakely <jwakely@redhat.com>
PR libstdc++/77998
test01()
{
{
- bool test __attribute__((unused)) = true;
-
const size_t len = 5;
typedef std::array<int, len> array_type;
array_type a = { { 0, 1, 2, 3, 4 } };
}
{
- bool test __attribute__((unused)) = true;
-
const size_t len = 0;
typedef std::array<int, len> array_type;
array_type a;
test01()
{
{
- bool test __attribute__((unused)) = true;
-
const size_t len = 5;
typedef std::array<int, len> array_type;
array_type a = { { 0, 1, 2, 3, 4 } };
}
{
- bool test __attribute__((unused)) = true;
-
const size_t len = 0;
typedef std::array<int, len> array_type;
array_type a;
test01()
{
{
- bool test __attribute__((unused)) = true;
-
const size_t len = 5;
typedef std::array<int, len> array_type;
array_type a = { { 0, 1, 2, 3, 4 } };
}
{
- bool test __attribute__((unused)) = true;
-
const size_t len = 0;
typedef std::array<int, len> array_type;
array_type a;
{
const size_t len = 5;
typedef std::array<int, len> array_type;
- bool test __attribute__((unused)) = true;
array_type a = { { 0, 1, 2, 3, 4 } };
array_type b = { { 0, 1, 2, 3, 4 } };
array_type c = { { 0, 1, 2, 3 } };
{
const size_t len = 5;
typedef std::array<int, len> array_type;
- bool test __attribute__((unused)) = true;
array_type a = { { 0, 1, 2, 3, 4 } };
array_type b = { { 0, 1, 2, 3, 4 } };
array_type c = { { 0, 1, 2, 3, 7 } };
{
const size_t len = 5;
typedef std::array<int, len> array_type;
- bool test __attribute__((unused)) = true;
array_type a = { { 0, 1, 2, 3, 4 } };
array_type b = { { 0, 1, 2, 3, 4 } };
array_type c = { { 0, 1, 2, 3, 7 } };
{
const size_t len = 5;
typedef std::array<int, len> array_type;
- bool test __attribute__((unused)) = true;
array_type a = { { 0, 1, 2, 3, 4 } };
array_type b = { { 0, 1, 2, 3, 4 } };
array_type c = { { 0, 1, 2, 3, 7 } };
{
const size_t len = 5;
typedef std::array<int, len> array_type;
- bool test __attribute__((unused)) = true;
array_type a = { { 0, 1, 2, 3, 4 } };
array_type b = { { 0, 1, 2, 3, 4 } };
array_type c = { { 0, 1, 2, 3, 7 } };
{
const size_t len = 5;
typedef std::array<int, len> array_type;
- bool test __attribute__((unused)) = true;
array_type a = { { 0, 1, 2, 3, 4 } };
array_type b = { { 0, 1, 2, 3, 4 } };
array_type c = { { 0, 1, 2, 3 } };
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const std::array<A, 1> a;
const A& aa = a.at(0);
VERIFY(aa.valid);
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const size_t len = 5;
typedef std::array<int, len> array_type;
array_type a = { { 0, 1, 2, 3, 4 } };
void
test01()
-{
- bool test __attribute__((unused)) = true;
-
+{
const size_t len = 5;
typedef std::array<int, len> array_type;
void
test01()
-{
- bool test __attribute__((unused)) = true;
-
+{
const size_t len = 5;
typedef std::array<int, len> array_type;
void
test01()
-{
- bool test __attribute__((unused)) = true;
-
+{
const size_t len = 5;
typedef std::array<int, len> array_type;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const size_t len = 5;
typedef std::array<int, len> array_type;
array_type a = { { 0, 1, 2, 3, 4 } };
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const size_t len = 5;
typedef std::array<int, len> array_type;
array_type a = { { 0, 1, 2, 3, 4 } };
// DR 776. Undescribed assign function of std::array.
void test01()
-{
- bool test __attribute__((unused)) = true;
-
+{
const size_t len = 3;
typedef std::array<int, len> array_type;
void
test01()
-{
- bool test __attribute__((unused)) = true;
-
+{
const size_t len = 5;
typedef std::array<int, len> array_type;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const size_t len = 0;
typedef std::array<int, len> array_type;
void
test01()
-{
- bool test __attribute__((unused)) = true;
-
+{
const size_t len = 5;
typedef std::array<int, len> array_type;
void
test01()
-{
- bool test __attribute__((unused)) = true;
+{
using std::array;
using std::tuple_element;
// This relies on the fact that <utility> includes <type_traits>:
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
const size_t len = 3;
void
test01()
-{
- bool test __attribute__((unused)) = true;
+{
using std::array;
using std::tuple_size;
// This relies on the fact that <utility> includes <type_traits>:
// DR 693. std::bitset::all() missing.
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::bitset<0> z1;
VERIFY( z1.all() );
z1.set();
#include <stdexcept>
#include <testsuite_hooks.h>
-bool test01(void)
+void test01(void)
{
- bool test __attribute__((unused)) = true;
-
// bitset()
const size_t n1 = 5;
std::bitset<n1> bit01;
catch(...) {
VERIFY( false );
}
- return test;
}
int main()
void test01()
{
using __gnu_debug::bitset;
- bool test __attribute__((unused)) = true;
bitset<5> b(7);
bitset<5> c;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
X x;
std::string s(x);
std::bitset<32> b1(static_cast<const char*>(x));
void test01()
{
- bool test __attribute__((unused)) = true;
-
const unsigned long long num0 = 0ULL;
std::bitset<0> bs0(num0);
VERIFY( bs0.to_ullong() == num0 );
// libstdc++/50268
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::bitset<1> b1(3ULL);
VERIFY( b1.count() == 1ULL );
// boundary condition: a zero-sized set
// libstdc++/6282
-bool test02(void)
+void test02(void)
{
using std::char_traits; using std::allocator;
- bool test __attribute__((unused)) = true;
std::bitset<0> z1;
VERIFY( z1.any() == false );
VERIFY( z1.to_ulong() == 0 );
VERIFY( (z1.to_string<char,char_traits<char>,allocator<char> >().empty() ));
- return test;
}
int main()
// DR 1325.
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
const char s1[4] = { '0', '1', '0', '1' };
// DR 396. what are characters zero and one.
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::bitset<4> z1(std::string("bbab"), 0, std::string::npos, 'a', 'b');
VERIFY( z1.to_string('a', 'b') == "bbab" );
void test01()
{
using namespace std;
- bool test __attribute__((unused)) = true;
bitset<256> b;
b.set(225);
void test01()
{
using namespace std;
- bool test __attribute__((unused)) = true;
bitset<5> b5;
bitset<0> b0;
template <size_t size>
bool
- do_test() {
- bool test __attribute__((unused)) = true;
+ do_test()
+ {
+ bool test = true;
std::bitset<size> shifted;
std::bitset<size> correct;
return test;
}
-bool
+void
test01() {
- bool test __attribute__((unused)) = true;
-
VERIFY( do_test<32>() );
VERIFY( do_test<48>() );
VERIFY( do_test<64>() );
VERIFY( do_test<511>() );
VERIFY( do_test<513>() );
VERIFY( do_test<997>() );
- return test;
}
int
void test01()
{
using __gnu_debug::bitset;
- bool test __attribute__((unused)) = true;
bitset<4> b0, b1;
b0.set(1);
#include <bitset>
#include <testsuite_hooks.h>
-bool
+void
test02()
{
- bool test __attribute__((unused)) = true;
-
std::bitset<66> b;
b <<= 400;
VERIFY( b.count() == 0 );
- return test;
}
int
void
test01(void)
{
- bool test __attribute__((unused)) = true;
const size_t n1 = 5;
// the other 22 member functions should be in here too...
catch(...) {
VERIFY( false );
}
- VERIFY( test );
}
int main()
void test01()
{
using namespace std;
- bool test __attribute__((unused)) = true;
bitset<5> b5;
string s0 = b5.to_string<char, char_traits<char>, allocator<char> >();
void test01()
{
using namespace std;
- bool test __attribute__((unused)) = true;
bitset<5> b5;
string s0 = b5.to_string<char, char_traits<char>, allocator<char> >('a', 'b');
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::bitset<0> bs0;
VERIFY( bs0.to_ullong() == 0 );
void test03()
{
- bool test __attribute__((unused)) = true;
std::bitset<5> b;
std::stringstream ss("101");
ss.exceptions(std::ios_base::eofbit);
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef CustomPointerAlloc<T> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v(1);
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<T> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::deque<T, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::deque<T, alloc_type> test_type;
test_type v1(1, alloc_type(1));
// libstdc++/29134
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
deque<int> d;
// libstdc++/29134
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::deque<int> d;
VERIFY( d.max_size() == d.get_allocator().max_size() );
void
test01()
{
- bool test __attribute__((unused)) = true;
-
std::deque<copycounter> a;
copycounter::copycount = 0;
a.resize(10);
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::deque<__gnu_test::NonCopyConstructible> d;
VERIFY( std::distance(d.begin(), d.end()) == 0 );
// libstdc++/42573
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<int> d(100);
d.push_back(1);
d.push_back(1);
typedef std::deque<__gnu_test::object_counter> gdeque;
-bool test __attribute__((unused)) = true;
-
// see http://gcc.gnu.org/ml/libstdc++/2001-11/msg00139.html
void
test01()
typedef std::deque<object_counter> gdeque;
-bool test __attribute__((unused)) = true;
-
// 23.2.1 required types
//
// A missing required type will cause a compile failure.
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
int data3[1000];
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::deque<__gnu_test::NonCopyConstructible> d(1000);
VERIFY( std::distance(d.begin(), d.end()) == 1000 );
for(auto it = d.begin(); it != d.end(); ++it)
int main()
{
- bool test __attribute__((unused)) = true;
-
std::deque<int> a,b;
a.push_back(1);
b = std::move(a);
void
test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::deque<int> deque_type;
typedef deque_type::iterator iterator_type;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::deque<std::deque<int> > deque_type;
typedef deque_type::iterator iterator_type;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::deque<T> deque_type;
typedef typename deque_type::iterator iterator_type;
void erase(size_t num_elm, size_t elm_strt, size_t elm_end)
{
- bool test __attribute__((unused)) = true;
using __gnu_test::copy_tracker;
using __gnu_test::assignment_operator;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace __gnu_test;
std::deque<copycounter> a(40);
void
test01()
{
- bool test __attribute__((unused)) = true;
-
std::deque<copycounter> a;
copycounter c(1);
copycounter::copycount = 0;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
std::deque<copycounter> a;
copycounter c(1);
copycounter::copycount = 0;
void
test03()
{
- bool test __attribute__((unused)) = true;
-
std::deque<copycounter> a(1000);
copycounter c(1);
copycounter::copycount = 0;
void
test04()
{
- bool test __attribute__((unused)) = true;
-
copycounter c(1);
std::deque<copycounter> a(10, c);
copycounter::copycount = 0;
void
test05()
{
- bool test __attribute__((unused)) = true;
-
copycounter c(1);
std::deque<copycounter> a(10, c);
copycounter::copycount = 0;
// libstdc++/49836
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::CopyConsOnlyType;
using __gnu_test::MoveConsOnlyType;
// libstdc++/49836
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::CopyConsOnlyType;
using __gnu_test::MoveConsOnlyType;
// Should use deque specialization for swap.
void test01()
{
- bool test __attribute__((unused)) = true;
std::deque<T> A;
std::deque<T> B;
swap_calls = 0;
// Should use deque specialization for swap.
void test02()
{
- bool test __attribute__((unused)) = true;
using namespace std;
deque<T> A;
deque<T> B;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef __gnu_test::uneq_allocator<char> my_alloc;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef __gnu_test::uneq_allocator<char> my_alloc;
// libstdc++/6503
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::deque<int> d(2);
typedef std::deque<int>::iterator iter;
typedef std::deque<int>::const_iterator constiter;
// libstdc++/7186
void test02()
{
- bool test __attribute__((unused)) = true;
-
std::deque<int> d(2);
typedef std::deque<int>::iterator iter;
typedef std::deque<int>::const_iterator constiter;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef CustomPointerAlloc<T> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<T> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::forward_list<T, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::forward_list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void
test01()
{
- bool test __attribute__((unused)) = true;
-
std::forward_list<double> fld;
VERIFY(fld.empty() == true);
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::forward_list<__gnu_test::NonCopyConstructible> fl;
VERIFY( std::distance(fl.begin(), fl.end()) == 0 );
#include <forward_list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
int main()
{
std::forward_list<double> a = {0.0, 1.0, 2.0, 3.0, 4.0};
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
-#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
// This test verifies the following:
// Default construction
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
-#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
// This test verifies the following:
// Construction from iterator range
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
-#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
// This test verifies the following:
// Move construction with allocator
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
-#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
// This test verifies the following:
// Construction from given number of default item
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
-#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
// This test verifies the following:
// Construction from given number of given item
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
-#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
// This test verifies the following:
// Construction from iterator range
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
-#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
// This test verifies the following:
// Copy construction
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
-#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
// This test verifies the following:
// Move construction
// 23.2.3.n forward_list xxx [lib.forward_list.xxx]
#include <forward_list>
-#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
// This test verifies the following.
// Construction from initializer list
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::forward_list<__gnu_test::NonCopyConstructible> fl(1000);
VERIFY( std::distance(fl.begin(), fl.end()) == 1000 );
for(auto it = fl.begin(); it != fl.end(); ++it)
#include <utility>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
int main()
{
std::forward_list<int> a, b;
void
test01()
{
- bool test __attribute__((unused)) = true;
std::forward_list<int> fl{1, 2, 3};
auto before = fl.before_begin();
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::forward_list<int, alloc_type> test_type;
test_type v1(alloc_type(1));
void
test01()
{
- bool test __attribute__((unused)) = true;
-
std::forward_list<int> fl1{1, 2, 3};
auto it = fl1.begin();
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::propagating_allocator<int, false> alloc_type;
typedef __gnu_debug::forward_list<int, alloc_type> test_type;
void
test01()
{
- bool test __attribute__((unused)) = true;
std::forward_list<int> fl1{1, 3, 5};
auto flit = fl1.before_begin();
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::forward_list<int, alloc_type> test_type;
void
test01()
{
- bool test __attribute__((unused)) = true;
std::forward_list<int> fl1{1, 2, 3};
std::forward_list<int> fl2{4, 5, 6};
void
test01()
{
- bool test __attribute__((unused)) = true;
std::forward_list<int> fl1{1, 3, 5};
std::forward_list<int> fl2{2, 4, 6};
#include <array>
-bool test __attribute__((unused)) = true;
-
class PathPoint
{
public:
#include <string>
-bool test __attribute__((unused)) = true;
-
// This test verifies the following:
// insert_after single item
// before_begin iterator
void
test01()
{
- bool test __attribute__((unused)) = true;
-
std::forward_list<int> fl({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int>::const_iterator pos = fl.cbegin();
void
test02()
{
- bool test __attribute__((unused)) = true;
-
std::forward_list<int> fl({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
std::forward_list<int>::const_iterator pos = fl.cbegin();
#include <forward_list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// This test verifies the following:
// swap
void
#include <forward_list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// This test verifies the following:
// clear
void
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::forward_list<int> fl1(1, 5), fl2(1, 4), fl3(1, 3),
fl4(1, 2), fl5(1, 1), fl6(1, 0);
#include <forward_list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// This test verifies the following:
//
void
#include <forward_list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// This test verifies the following:
// remove
void
#include <algorithm>
-bool test __attribute__((unused)) = true;
-
// This test verifies the following:
// remove_if
void
#include <forward_list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// This test verifies the following:
// unique
void
#include <forward_list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// This test verifies the following:
//
void
#include <forward_list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// Comparison functor.
template<typename Num>
class Comp
#include <algorithm>
-bool test __attribute__((unused)) = true;
-
// This test verifies the following:
//
void
// Used to cause many Valgrind errors: LWG 526-type situation.
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::forward_list<int> fl1;
fl1.push_front(1);
int main()
{
- bool test __attribute__((unused)) = true;
-
#if _GLIBCXX_USE_DUAL_ABI
std::list<short> l;
testm(l);
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<T> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::list<T, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::list<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void
capacity01()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
typedef typename list_type::iterator iterator_type;
// libstdc++/29134
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::list<int> list_type;
list_type l;
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::list<__gnu_test::NonCopyConstructible> l;
VERIFY( std::distance(l.begin(), l.end()) == 0 );
void
cons01()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
list_type list0101;
void
cons021()
{
- bool test __attribute__((unused)) = true;
const std::size_t LIST_SIZE = 5;
const int INIT_VALUE = 7;
std::size_t count;
void
cons03()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
typedef typename list_type::iterator iterator;
void
cons04()
{
- bool test __attribute__((unused)) = true;
const int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
const std::size_t N = sizeof(A) / sizeof(int);
std::size_t count;
void
cons05()
{
- bool test __attribute__((unused)) = true;
const int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
const std::size_t N = sizeof(A) / sizeof(int);
int count;
void
cons06()
{
- bool test __attribute__((unused)) = true;
const int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
const int B[] = {101, 102, 103, 104, 105};
const std::size_t N = sizeof(A) / sizeof(int);
void
cons07()
{
- bool test __attribute__((unused)) = true;
const std::size_t BIG_LIST_SIZE = 11;
const int BIG_INIT_VALUE = 7;
const std::size_t SMALL_LIST_SIZE = 5;
{
typedef _Tp list_type;
typedef typename list_type::iterator iterator;
- bool test __attribute__((unused)) = true;
const std::size_t LIST_SIZE = 5;
const int INIT_VALUE = 7;
std::size_t count = 0;
void
cons09()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
typedef typename list_type::iterator iterator;
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::list<__gnu_test::NonCopyConstructible> l(1000);
VERIFY( std::distance(l.begin(), l.end()) == 1000 );
for(auto it = l.begin(); it != l.end(); ++it)
void
test_moveable()
{
- bool test __attribute__((unused)) = true;
-
typedef _Tp list_type;
list_type a,b;
{
using std::advance;
- bool test __attribute__((unused)) = true;
-
typedef __gnu_debug::list<int> list_type;
list_type v1;
list_type v2;
void test02()
{
using std::advance;
-
- bool test __attribute__((unused)) = true;
-
+
typedef __gnu_debug::list<int> list_type;
list_type v(10, 17);
void test03()
{
using std::advance;
-
- bool test __attribute__((unused)) = true;
+
typedef __gnu_debug::list<int> list_type;
list_type v(20, 42);
void test04()
{
using std::advance;
-
- bool test __attribute__((unused)) = true;
typedef __gnu_debug::list<int> list_type;
void
modifiers1()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
typedef typename list_type::iterator iterator;
typedef typename list_type::value_type value_type;
void
modifiers2()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
typedef typename list_type::value_type value_type;
typedef typename list_type::iterator iterator;
void
modifiers3()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
typedef typename list_type::iterator iterator;
typedef typename list_type::value_type value_type;
template<typename _Tp>
void insert1()
{
- bool test __attribute__((unused)) = true;
-
typedef _Tp list_type;
typedef typename _Tp::value_type value_type;
typedef typename _Tp::allocator_type allocator_type;
void
swap11()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
list_type A;
swap12()
{
using namespace std;
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
list_type A;
void
swap2()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef _Tp list_type;
void
swap3()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef _Tp list_type;
void
operations01()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
typedef typename list_type::iterator iterator;
void
operations02()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
typedef typename list_type::iterator iterator;
void
operations03()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
typedef typename list_type::iterator iterator;
void
operations04()
{
- bool test __attribute__((unused)) = true;
typedef _Tp list_type;
const int A[] = {1, 2, 3, 4, 5, 6};
// PR libstdc++/42352
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::list<int> l{3, 2, 4, 1, 5, 9, 0, 8, 6, 7};
l.sort();
void test02()
{
- bool test __attribute__((unused)) = true;
-
std::list<int> l{3, 2, 4, 1, 5, 9, 0, 8, 6, 7};
struct compare
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef tracker_allocator<std::pair<const int, int>> alloc_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef tracker_allocator<std::pair<const int, int>> alloc_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<std::pair<const T, U>> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<std::pair<const T, U>> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<std::pair<const T, U>> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef propagating_allocator<std::pair<const int, int>, false,
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::map<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
// libstdc++/29134
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::map<int, int> m;
VERIFY( (m.max_size() == std::allocator<std::_Rb_tree_node<
int main()
{
- bool test __attribute__((unused)) = true;
-
std::map<int, int> a,b;
a[2]=0;
b[1]=0;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::map<int, int, std::less<int>, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::propagating_allocator<std::pair<const int, int>,
false> alloc_type;
typedef __gnu_debug::map<int, int, std::less<int>, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::map<int, int, std::less<int>, alloc_type> test_type;
// libstdc++/23578
void test01()
-{
- bool test __attribute__((unused)) = true;
+{
typedef std::map<int, double> map_type;
{
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::map<rvalstruct, rvalstruct> Map;
// c++/39901
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::map<std::pair<int, int>, int> the_map;
the_map[{0, 1}] = 5;
using namespace std;
-int test01()
+void test01()
{
- bool test __attribute__((unused)) = true;
-
map<int,double> m({ { 1, 1.0 }, { 2, 2.0 }, { 42, 237.0 } });
VERIFY(m.size() == 3);
VERIFY(m[1] == 1.0);
VERIFY(m[6] == 66.0);
VERIFY(m[7] == 77.0);
VERIFY(m[8] == 88.0);
- return test;
}
int main()
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
map<int, int> m0;
void
test02()
{
- bool test __attribute__((unused)) = true;
using namespace std;
map<int, int> m0;
std::vector<double> coords;
};
-bool test __attribute__((unused)) = true;
-
void test01()
{
typedef std::map<char, std::vector<double>> Map;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ {1, 10}, {2, 20}, {3, 30} };
test_type::node_type node;
test_type::insert_return_type ins;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ {1, 10}, {2, 20}, {3, 30} };
test_type::node_type node;
test_type::insert_return_type ins;
// http://gcc.gnu.org/ml/gcc-patches/2001-08/msg01375.html
void test01()
{
- bool test __attribute__((unused)) = true;
typedef std::map<int, int> Map;
Map M;
Map::iterator hint;
void test01()
{
using __gnu_debug::map;
- bool test __attribute__((unused)) = true;
map<int, float> m1, m2;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::map<int, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::map<int, rvalstruct> Map;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::map<rvalstruct, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::map<rvalstruct, rvalstruct> Map;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::map<int, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::map<int, rvalstruct> Map;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::map<rvalstruct, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::map<rvalstruct, rvalstruct> Map;
#include <map>
#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
-
struct Val
{
bool moved_from_ctor = false;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {2, 20}, {3, 30} };
test_type c1 = c0, c2 = c0;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {2, 20}, {3, 30} };
test_type c1 = c0;
std::map<int, int, std::less<>> c2( c0.begin(), c0.end() );
void
test03()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {2, 20}, {3, 30} };
test_type c1 = c0;
std::map<int, int, std::greater<>> c2( c0.begin(), c0.end() );
void
test04()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {2, 20}, {3, 30} };
test_type c1 = c0;
std::multimap<int, int, std::greater<>> c2( c0.begin(), c0.end() );
// Should use map specialization for swap.
void test01()
{
- bool test __attribute__((unused)) = true;
std::map<T, int> A;
std::map<T, int> B;
swap_calls = 0;
// Should use map specialization for swap.
void test02()
{
- bool test __attribute__((unused)) = true;
using namespace std;
map<T, int> A;
map<T, int> B;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef pair<const char, int> my_pair;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef pair<const char, int> my_pair;
#include <map>
#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
-
struct Val
{
bool moved_from_ctor = false;
// A few tests for equal_range, in the occasion of libstdc++/29385.
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
map<int, int> m0;
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef map<int, int>::value_type value_type;
// libstdc++/86: map & set iterator comparisons are not type-safe
void test01()
{
- bool test __attribute__((unused)) = true;
std::map<unsigned int, int> mapByIndex;
std::map<std::string, unsigned> mapByName;
void test01()
{
- bool test __attribute__((unused)) = true;
-
using __gnu_test::rvalstruct;
using __gnu_test::counter_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef tracker_allocator<std::pair<const int, int>> alloc_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef tracker_allocator<std::pair<const int, int>> alloc_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<std::pair<const T, U>> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<std::pair<const T, U>> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<std::pair<const T, U>> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef propagating_allocator<std::pair<const int, int>, false,
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, false> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, U>, true> alloc_type;
typedef std::multimap<T, U, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
// libstdc++/29134
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::multimap<int, int> mm;
VERIFY( (mm.max_size() == std::allocator<std::_Rb_tree_node<
int main()
{
- bool test __attribute__((unused)) = true;
-
std::multimap<int, int> a,b;
a.insert(std::make_pair(2,0));
b.insert(std::make_pair(1,0));
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::multimap<int, int, std::less<int>, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::propagating_allocator<std::pair<const int, int>,
false> alloc_type;
typedef __gnu_debug::multimap<int, int, std::less<int>, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::multimap<int, int, std::less<int>, alloc_type> test_type;
using namespace std;
-int test01()
+void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef multimap<int,double> Container;
typedef Container::iterator iterator;
typedef pair<iterator,iterator> itpair;
VERIFY(m.count(5) == 2);
VERIFY(m.count(42) == 1);
VERIFY(m.count(7) == 2);
-
- return test;
}
int main()
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
multimap<int, int> mm0;
void
test02()
{
- bool test __attribute__((unused)) = true;
using namespace std;
multimap<int, int> mm0;
std::vector<double> coords;
};
-bool test __attribute__((unused)) = true;
-
void test01()
{
typedef std::multimap<char, std::vector<double>> MMap;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ {1, 10}, { 1, 11 }, {2, 20}, { 2, 21}, {3, 30}, { 3, 31 } };
test_type::node_type node;
test_type::iterator pos;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ {1, 10}, { 1, 11 }, {2, 20}, { 2, 21}, {3, 30}, { 3, 31 } };
test_type::node_type node;
test_type::iterator pos;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multimap<int, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multimap<int, rvalstruct> Map;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multimap<rvalstruct, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multimap<rvalstruct, rvalstruct> Map;
// libstdc++/22102
void test01()
{
- bool test __attribute__((unused)) = true;
typedef std::multimap<int, int> Mmap;
typedef Mmap::value_type value_type;
typedef Mmap::iterator iterator;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multimap<int, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multimap<int, rvalstruct> Map;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multimap<rvalstruct, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multimap<rvalstruct, rvalstruct> Map;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {1, 11}, {2, 20}, {2, 21}, {3, 30}, {3, 31} };
test_type c1 = c0, c2 = c0;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {1, 11}, {2, 20}, {2, 21}, {3, 30}, {3, 31} };
test_type c1 = c0;
std::multimap<int, int, std::less<>> c2( c0.begin(), c0.end() );
void
test03()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {1, 11}, {2, 20}, {2, 21}, {3, 30}, {3, 31} };
test_type c1 = c0;
std::multimap<int, int, std::greater<>> c2( c0.begin(), c0.end() );
void
test04()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {1, 11}, {2, 20}, {2, 21}, {3, 30}, {3, 31} };
test_type c1 = c0;
std::map<int, int, std::greater<>> c2( c0.begin(), c0.end() );
// Should use multimap specialization for swap.
void test01()
{
- bool test __attribute__((unused)) = true;
std::multimap<T, int> A;
std::multimap<T, int> B;
swap_calls = 0;
// Should use multimap specialization for swap.
void test02()
{
- bool test __attribute__((unused)) = true;
using namespace std;
multimap<T, int> A;
multimap<T, int> B;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef pair<const char, int> my_pair;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef pair<const char, int> my_pair;
// A few tests for equal_range, in the occasion of libstdc++/29385.
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
multimap<int, int> mm0;
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef multimap<int, int>::value_type value_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef tracker_allocator<int> alloc_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef tracker_allocator<int> alloc_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<T> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef propagating_allocator<int, false, tracker_allocator<int>> alloc_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::multiset<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
// libstdc++/29134
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::multiset<int> ms;
VERIFY( ms.max_size()
int main()
{
- bool test __attribute__((unused)) = true;
-
std::multiset<int> a,b;
a.insert(2);
b.insert(1);
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::multiset<int, std::less<int>, alloc_type> test_type;
// Erase
void test02()
{
- bool test __attribute__((unused)) = true;
multiset<int> v;
for (int i = 0; i < 20; ++i)
v.insert(i);
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::propagating_allocator<int, false> alloc_type;
typedef __gnu_debug::multiset<int, std::less<int>, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::multiset<int, std::less<int>, alloc_type> test_type;
using namespace std;
-int test01()
+void test01()
{
- bool test __attribute__((unused)) = true;
-
multiset<int> m({ 1, 5, 5, 37 });
VERIFY(m.size() == 4);
VERIFY(m.count(1) == 1);
VERIFY(m.count(102) == 1);
VERIFY(m.count(42) == 2);
VERIFY(m.count(1) == 0);
-
- return test;
}
int main()
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
multiset<int> ms0;
void
test02()
{
- bool test __attribute__((unused)) = true;
using namespace std;
multiset<int> ms0;
{ return __lhs.getType() < __rhs.getType(); }
};
-bool test __attribute__((unused)) = true;
-
void test01()
{
typedef std::multiset<PathPoint, PathPointLess> Mset;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ 1, 1, 2, 2, 3, 3 };
test_type::node_type node;
test_type::iterator pos;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ 1, 1, 2, 2, 3, 3 };
test_type::node_type node;
test_type::iterator pos;
int main ()
{
- bool test __attribute__((unused)) = true;
typedef std::multiset<std::pair<int, int> >::iterator iterator;
std::pair<int, int> p(69, 0);
std::multiset<std::pair<int, int> > s;
// and libstdc++/19433.
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
multiset<int> ms0, ms1;
// libstdc++/22102
void test01()
{
- bool test __attribute__((unused)) = true;
typedef std::multiset<int> Mset;
typedef Mset::value_type value_type;
typedef Mset::iterator iterator;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multiset<rvalstruct> Set;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multiset<rvalstruct> Set;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multiset<rvalstruct> Set;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::multiset<rvalstruct> Set;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
test_type c0{ 1, 1, 2, 2, 3, 3 };
test_type c1 = c0, c2 = c0;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
test_type c0{ 1, 1, 2, 2, 3, 3 };
test_type c1 = c0;
std::multiset<int, std::less<>> c2( c0.begin(), c0.end() );
void
test04()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ 1, 1, 2, 2, 3, 3 };
test_type c1 = c0;
std::set<int, std::greater<>> c2( c0.begin(), c0.end() );
// Should use multiset specialization for swap.
void test01()
{
- bool test __attribute__((unused)) = true;
std::multiset<T> A;
std::multiset<T> B;
swap_calls = 0;
// Should use multiset specialization for swap.
void test02()
{
- bool test __attribute__((unused)) = true;
using namespace std;
multiset<T> A;
multiset<T> B;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef __gnu_test::uneq_allocator<char> my_alloc;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef __gnu_test::uneq_allocator<char> my_alloc;
// A few tests for equal_range, in the occasion of libstdc++/29385.
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
multiset<int> ms0;
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
multiset<int> ms0;
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::priority_queue<int> a,b;
a.push(1);
b = std::move(a);
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::queue<int> a,b;
a.push(1);
b = std::move(a);
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef tracker_allocator<int> alloc_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef tracker_allocator<int> alloc_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<T> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::set<T, Cmp, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef propagating_allocator<int, false, tracker_allocator<int>> alloc_type;
void test04()
{
- bool test __attribute__((unused)) = true;
-
using namespace __gnu_test;
typedef tracker_allocator<int> alloc_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::set<T, Cmp, alloc_type> test_type;
test_type v1(alloc_type(1));
// libstdc++/29134
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::set<int> s;
VERIFY( s.max_size() ==
int main()
{
- bool test __attribute__((unused)) = true;
-
std::set<int> a,b;
a.insert(2);
b.insert(1);
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::set<int, std::less<int>, alloc_type> test_type;
// Erase
void test02()
{
- bool test __attribute__((unused)) = true;
-
set<int> v;
for (int i = 0; i < 20; ++i)
v.insert(i);
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::propagating_allocator<int, false> alloc_type;
typedef __gnu_debug::set<int, std::less<int>, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::set<int, std::less<int>, alloc_type> test_type;
using namespace std;
-int test01()
+void test01()
{
- bool test __attribute__((unused)) = true;
-
set<int> m({ 1, 5, 37 });
VERIFY(m.size() == 3);
VERIFY(m.count(1) == 1);
VERIFY(m.count(102) == 1);
VERIFY(m.count(42) == 1);
VERIFY(m.count(1) == 0);
-
- return test;
}
int main()
// libstdc++/17948
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef set<int>::size_type size_type;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
set<int> s0;
void
test02()
{
- bool test __attribute__((unused)) = true;
using namespace std;
set<int> s0;
{ return __lhs.getType() < __rhs.getType(); }
};
-bool test __attribute__((unused)) = true;
-
void test01()
{
typedef std::set<PathPoint, PathPointLess> Set;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ 1, 2, 3 };
test_type::node_type node;
test_type::insert_return_type ins;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ 1, 2, 3 };
test_type::node_type node;
test_type::insert_return_type ins;
// and libstdc++/19433.
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
set<int> s0, s1;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::set<rvalstruct> Set;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::set<rvalstruct> Set;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::set<rvalstruct> Set;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::set<rvalstruct> Set;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ 1, 2, 3 };
test_type c1 = c0, c2 = c0;
c1.merge(c2);
void
test02()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ 1, 2, 3 };
test_type c1 = c0;
std::set<int, std::less<>> c2( c0.begin(), c0.end() );
void
test03()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ 1, 2, 3 };
test_type c1 = c0;
std::set<int, std::greater<>> c2( c0.begin(), c0.end() );
void
test04()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ 1, 2, 3 };
test_type c1 = c0;
std::multiset<int, std::greater<>> c2( c0.begin(), c0.end() );
// Should use set specialization for swap.
void test01()
{
- bool test __attribute__((unused)) = true;
std::set<T> A;
std::set<T> B;
swap_calls = 0;
// Should use set specialization for swap.
void test02()
{
- bool test __attribute__((unused)) = true;
using namespace std;
set<T> A;
set<T> B;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef __gnu_test::uneq_allocator<char> my_alloc;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef __gnu_test::uneq_allocator<char> my_alloc;
// A few tests for equal_range, in the occasion of libstdc++/29385.
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
set<int> s0;
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
set<int> s0;
// libstdc++/86: map & set iterator comparisons are not type-safe
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::set<unsigned int> setByIndex;
std::set<std::string> setByName;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<T> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<counter_type, false> alloc_type;
typedef __gnu_test::counter_type_hasher hash;
typedef std::unordered_map<counter_type, counter_type, hash,
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<counter_type, true> alloc_type;
typedef __gnu_test::counter_type_hasher hash;
typedef std::unordered_map<counter_type, counter_type, hash,
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, T>, false> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
typedef std::unordered_map<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
int main()
{
- bool test __attribute__((unused)) = true;
-
std::unordered_map<int, int> a,b;
a[2]=0;
b[1]=0;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::uneq_allocator<std::pair<const int, int>> alloc_type;
typedef __gnu_debug::unordered_map<int, int, std::hash<int>,
std::equal_to<int>,
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::propagating_allocator<std::pair<const int, int>,
false> alloc_type;
typedef __gnu_debug::unordered_map<int, int,
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::unordered_map<
int, int, std::hash<int>, std::equal_to<int>, alloc_type> test_type;
// DR 761. unordered_map needs an at() member function.
void test01()
-{
- bool test __attribute__((unused)) = true;
+{
typedef std::unordered_map<int, double> map_type;
{
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_map<std::string, int> Map;
typedef Map::iterator iterator;
typedef Map::const_iterator const_iterator;
// libstdc++/24061
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_map<std::string, int> Map;
typedef Map::iterator iterator;
typedef Map::const_iterator const_iterator;
#include <unordered_map>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
struct A
{
int x;
// DR 1189. Awkward interface for changing the number of buckets
// in an unordered associative container
void test01()
-{
- bool test __attribute__((unused)) = true;
-
+{
std::unordered_map<int, double> m1;
m1.reserve(10);
VERIFY( m1.bucket_count() >= 10 );
using namespace std;
-int test01()
+void test01()
{
- bool test __attribute__((unused)) = true;
-
unordered_map<int,double> m({ { 1, 1.0 }, { 2, 2.0 }, { 42, 237.0 } });
VERIFY(m.size() == 3);
VERIFY(m[1] == 1.0);
VERIFY(m[6] == 66.0);
VERIFY(m[7] == 77.0);
VERIFY(m[8] == 88.0);
- return test;
}
int main()
// libstdc++/24061
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_map<std::string, int> Map;
typedef Map::iterator iterator;
typedef Map::const_iterator const_iterator;
+++ /dev/null
-// { dg-do run { target c++11 } }
-//
-// Copyright (C) 2013-2016 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with this library; see the file COPYING3. If not see
-// <http://www.gnu.org/licenses/>.
-
-#include <unordered_map>
-#include <string>
-#include <testsuite_hooks.h>
-
-void test01()
-{
- bool test __attribute__((unused)) = true;
-
- {
- std::unordered_map<std::string, std::string> mymap;
- std::pair<std::string, std::string> mypair{std::string("key"),
- std::string("value")};
- mymap.insert(mypair);
-
- VERIFY( mypair.first.length() && mypair.second.length() );
- }
-
- {
- std::unordered_map<std::string, std::string> mymap;
- std::pair<std::string, std::string> mypair{std::string("key"),
- std::string("value")};
- mymap.insert(mymap.begin(), mypair);
-
- VERIFY( mypair.first.length() && mypair.second.length() );
- }
-}
-
-int main()
-{
- test01();
- return 0;
-}
--- /dev/null
+// { dg-do run { target c++11 } }
+//
+// Copyright (C) 2013-2016 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <unordered_map>
+#include <string>
+#include <testsuite_hooks.h>
+
+void test01()
+{
+ {
+ std::unordered_map<std::string, std::string> mymap;
+ std::pair<std::string, std::string> mypair{std::string("key"),
+ std::string("value")};
+ mymap.insert(mypair);
+
+ VERIFY( mypair.first.length() && mypair.second.length() );
+ }
+
+ {
+ std::unordered_map<std::string, std::string> mymap;
+ std::pair<std::string, std::string> mypair{std::string("key"),
+ std::string("value")};
+ mymap.insert(mymap.begin(), mypair);
+
+ VERIFY( mypair.first.length() && mypair.second.length() );
+ }
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_map<std::string, int> Map;
Map m;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_map<rvalstruct, rvalstruct> Map;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_map<std::string, int> Map;
typedef std::pair<const std::string, int> Pair;
void test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_map<std::string, int> Map;
typedef std::pair<const std::string, int> Pair;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_map<std::string, int> Map;
typedef std::pair<const std::string, int> Pair;
void test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_map<std::string, int> Map;
typedef std::pair<const std::string, int> Pair;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_map<int, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_map<int, rvalstruct> Map;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_map<rvalstruct, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_map<rvalstruct, rvalstruct> Map;
#include <unordered_map>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
void test01()
{
std::unordered_map<int, int> um(20);
std::vector<double> coords;
};
-bool test __attribute__((unused)) = true;
-
void test01()
{
typedef std::unordered_map<char, std::vector<double>> Map;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ {1, 10}, {2, 20}, {3, 30} };
test_type::node_type node;
test_type::insert_return_type ins;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ {1, 10}, {2, 20}, {3, 30} };
test_type::node_type node;
test_type::insert_return_type ins;
#include <unordered_map>
#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
-
struct Val
{
bool moved_from_ctor = false;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {2, 20}, {3, 30} };
test_type c1 = c0, c2 = c0;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {2, 20}, {3, 30} };
test_type c1 = c0;
std::unordered_map<int, int, hash, equal> c2( c0.begin(), c0.end() );
void
test03()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {2, 20}, {3, 30} };
test_type c1 = c0;
std::unordered_multimap<int, int, hash, equal> c2( c0.begin(), c0.end() );
#include <unordered_map>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
void test01()
{
const int N = 1000;
#include <functional>
#include <testsuite_hooks.h>
-
-bool test __attribute__((unused)) = true;
-
struct Val
{
bool moved_from_ctor = false;
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef unordered_map<int, int>::value_type value_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::pair<const int, int> Pair;
std::unordered_map<int, int> um1, um2;
VERIFY( um1 == um2 );
void test01()
{
- bool test __attribute__((unused)) = true;
-
using __gnu_test::rvalstruct;
using __gnu_test::counter_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<T> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<counter_type, false> alloc_type;
typedef __gnu_test::counter_type_hasher hash;
typedef std::unordered_multimap<counter_type, counter_type, hash,
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<counter_type, true> alloc_type;
typedef __gnu_test::counter_type_hasher hash;
typedef std::unordered_multimap<counter_type, counter_type, hash,
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, T>, false> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<std::pair<const T, T>, true> alloc_type;
typedef std::unordered_multimap<T, T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
int main()
{
- bool test __attribute__((unused)) = true;
-
std::unordered_multimap<int, int> a,b;
a.insert(std::make_pair(2,0));
b.insert(std::make_pair(1,0));
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::uneq_allocator<std::pair<const int, int>> alloc_type;
typedef __gnu_debug::unordered_multimap<int, int,
std::hash<int>, std::equal_to<int>,
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::propagating_allocator<std::pair<const int, int>,
false> alloc_type;
typedef __gnu_debug::unordered_multimap<int, int, std::hash<int>,
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef uneq_allocator<std::pair<const int, int> > alloc_type;
typedef __gnu_debug::unordered_multimap<
int, int, std::hash<int>, std::equal_to<int>, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<std::string, int> Mmap;
typedef Mmap::iterator iterator;
typedef Mmap::const_iterator const_iterator;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<std::string, int> Mmap;
typedef Mmap::iterator iterator;
typedef Mmap::const_iterator const_iterator;
// libstdc++/24061
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<std::string, int> Mmap;
typedef Mmap::iterator iterator;
typedef Mmap::const_iterator const_iterator;
// libstdc++/51845
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<int, int> Mmap;
typedef Mmap::iterator iterator;
typedef Mmap::const_iterator const_iterator;
#include <unordered_map>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
struct A
{
int x;
// DR 1189. Awkward interface for changing the number of buckets
// in an unordered associative container
void test01()
-{
- bool test __attribute__((unused)) = true;
-
+{
std::unordered_multimap<int, double> mm1;
mm1.reserve(10);
VERIFY( mm1.bucket_count() >= 10 );
using namespace std;
-int test01()
+void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef unordered_multimap<int,double> Container;
typedef Container::const_iterator iterator;
typedef pair<iterator,iterator> itpair;
VERIFY(m.count(5) == 2);
VERIFY(m.count(42) == 1);
VERIFY(m.count(7) == 2);
-
- return test;
}
int main()
// libstdc++/24061
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<std::string, int> Mmap;
typedef Mmap::iterator iterator;
typedef Mmap::const_iterator const_iterator;
// libstdc++/51866
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::unordered_multimap<num, int, num_hash, num_equal> mmap;
mmap.insert(std::make_pair(num(1), 1));
mmap.insert(std::make_pair(num(2), 2));
void test01()
{
using namespace std;
- bool test __attribute__((unused)) = true;
-
+
unordered_multimap<int, int> mmap;
vector<int> values;
void test01()
{
using namespace std;
- bool test __attribute__((unused)) = true;
std::unordered_multimap<int, int> umm;
umm.insert(make_pair(10, 1));
+++ /dev/null
-// { dg-do run { target c++11 } }
-//
-// Copyright (C) 2013-2016 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 3, or (at your option)
-// any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with this library; see the file COPYING3. If not see
-// <http://www.gnu.org/licenses/>.
-
-#include <unordered_map>
-#include <string>
-#include <testsuite_hooks.h>
-
-void test01()
-{
- bool test __attribute__((unused)) = true;
-
- {
- std::unordered_multimap<std::string, std::string> mymmap;
- std::pair<std::string, std::string> mypair{std::string("key"),
- std::string("value")};
- mymmap.insert(mypair);
-
- VERIFY( mypair.first.length() && mypair.second.length() );
- }
-
- {
- std::unordered_multimap<std::string, std::string> mymmap;
- std::pair<std::string, std::string> mypair{std::string("key"),
- std::string("value")};
- mymmap.insert(mymmap.begin(), mypair);
-
- VERIFY( mypair.first.length() && mypair.second.length() );
- }
-}
-
-int main()
-{
- test01();
- return 0;
-}
--- /dev/null
+// { dg-do run { target c++11 } }
+//
+// Copyright (C) 2013-2016 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <unordered_map>
+#include <string>
+#include <testsuite_hooks.h>
+
+void test01()
+{
+ {
+ std::unordered_multimap<std::string, std::string> mymmap;
+ std::pair<std::string, std::string> mypair{std::string("key"),
+ std::string("value")};
+ mymmap.insert(mypair);
+
+ VERIFY( mypair.first.length() && mypair.second.length() );
+ }
+
+ {
+ std::unordered_multimap<std::string, std::string> mymmap;
+ std::pair<std::string, std::string> mypair{std::string("key"),
+ std::string("value")};
+ mymmap.insert(mymmap.begin(), mypair);
+
+ VERIFY( mypair.first.length() && mypair.second.length() );
+ }
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<int, int> Map;
typedef typename Map::value_type Pair;
void test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<int, int, hasher> Map;
typedef typename Map::value_type Pair;
void test03()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<int, int> Map;
typedef typename Map::value_type Pair;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<std::string, int> Map;
typedef std::pair<const std::string, int> Pair;
void test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<std::string, int> Map;
typedef std::pair<const std::string, int> Pair;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<std::string, int> Map;
typedef std::pair<const std::string, int> Pair;
void test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multimap<std::string, int> Map;
typedef std::pair<const std::string, int> Pair;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_multimap<int, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_multimap<int, rvalstruct> Map;
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_multimap<rvalstruct, rvalstruct> Map;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_multimap<rvalstruct, rvalstruct> Map;
std::vector<double> coords;
};
-bool test __attribute__((unused)) = true;
-
void test01()
{
typedef std::unordered_multimap<char, std::vector<double>> MMap;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ {1, 10}, { 1, 11 }, {2, 20}, { 2, 21}, {3, 30}, { 3, 31 } };
test_type::node_type node;
test_type::iterator pos;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ {1, 10}, { 1, 11 }, {2, 20}, { 2, 21}, {3, 30}, { 3, 31 } };
test_type::node_type node;
test_type::iterator pos;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {1, 11}, {2, 20}, {2, 21}, {3, 30}, {3, 31} };
test_type c1 = c0, c2 = c0;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {1, 11}, {2, 20}, {2, 21}, {3, 30}, {3, 31} };
test_type c1 = c0;
std::unordered_multimap<int, int, hash, equal> c2( c0.begin(), c0.end() );
void
test03()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {1, 11}, {2, 20}, {2, 21}, {3, 30}, {3, 31} };
test_type c1 = c0;
std::unordered_multimap<int, int, hash, equal> c2( c0.begin(), c0.end() );
void
test04()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ {1, 10}, {1, 11}, {2, 20}, {2, 21}, {3, 30}, {3, 31} };
test_type c1 = c0;
std::unordered_map<int, int, hash, equal> c2( c0.begin(), c0.end() );
#include <unordered_map>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
void test01()
{
const int N = 1000;
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef unordered_multimap<int, int>::value_type value_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::pair<const int, int> Pair;
std::unordered_multimap<int, int> umm1, umm2;
VERIFY( umm1 == umm2 );
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::pair<const int, int> Pair;
std::unordered_multimap<int, int> umm1, umm2;
VERIFY( umm1 == umm2 );
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<T> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<counter_type, false> alloc_type;
typedef __gnu_test::counter_type_hasher hash;
typedef std::unordered_multiset<counter_type, hash,
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<counter_type, true> alloc_type;
typedef __gnu_test::counter_type_hasher hash;
typedef std::unordered_multiset<counter_type, hash,
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_multiset<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
int main()
{
- bool test __attribute__((unused)) = true;
-
const int nb = 10000;
std::unordered_multiset<int> ref;
for (int i = 0; i != nb; ++i)
int main()
{
- bool test __attribute__((unused)) = true;
-
std::unordered_multiset<int> a,b;
a.insert(2);
b.insert(1);
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::unordered_multiset<int, std::hash<int>,
std::equal_to<int>,
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::propagating_allocator<int, false> alloc_type;
typedef __gnu_debug::unordered_multiset<int, std::hash<int>,
std::equal_to<int>,
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::unordered_multiset<
int, std::hash<int>, std::equal_to<int>, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multiset<std::string> Mset;
typedef Mset::iterator iterator;
typedef Mset::const_iterator const_iterator;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multiset<std::string> Mset;
typedef Mset::iterator iterator;
typedef Mset::const_iterator const_iterator;
// libstdc++/24061
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multiset<std::string> Mset;
typedef Mset::iterator iterator;
typedef Mset::const_iterator const_iterator;
// DR 1189. Awkward interface for changing the number of buckets
// in an unordered associative container
void test01()
-{
- bool test __attribute__((unused)) = true;
-
+{
std::unordered_multiset<int> ms1;
ms1.reserve(10);
VERIFY( ms1.bucket_count() >= 10 );
using namespace std;
-int test01()
+void test01()
{
- bool test __attribute__((unused)) = true;
-
unordered_multiset<int> m({ 1, 5, 5, 37 });
VERIFY(m.size() == 4);
VERIFY(m.count(1) == 1);
VERIFY(m.count(102) == 1);
VERIFY(m.count(42) == 2);
VERIFY(m.count(1) == 0);
-
- return test;
}
int main()
// libstdc++/24061
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multiset<std::string> Mset;
typedef Mset::iterator iterator;
typedef Mset::const_iterator const_iterator;
// libstdc++/51866
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::unordered_multiset<num, num_hash, num_equal> mset;
mset.insert(num(1));
mset.insert(num(2));
void test01()
{
using namespace std;
- bool test __attribute__((unused)) = true;
-
+
unordered_multiset<pair<int, int>, pair_hash, pair_equal_to> mset;
vector<int> values;
void test01()
{
using namespace std;
- bool test __attribute__((unused)) = true;
std::unordered_multiset<int> mms;
mms.insert(10);
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::numeric_limits<size_t> nl_size_t;
std::unordered_multiset<int, std::hash<int>, std::equal_to<int>,
__gnu_cxx::throw_allocator_limit<int> > us;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multiset<std::string> Set;
Set s;
VERIFY(s.empty());
void test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multiset<int> Set;
Set s;
VERIFY(s.empty());
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multiset<std::string> Set;
Set s;
VERIFY(s.empty());
void test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_multiset<std::string> Set;
Set s;
VERIFY(s.empty());
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_multiset<rvalstruct> Set;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_multiset<rvalstruct> Set;
{ return __lhs.getType() == __rhs.getType(); }
};
-bool test __attribute__((unused)) = true;
-
void test01()
{
typedef std::unordered_multiset<PathPoint, PathPointHasher,
void
test01()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ 1, 1, 2, 2, 3, 3 };
test_type::node_type node;
test_type::iterator pos;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ 1, 1, 2, 2, 3, 3 };
test_type::node_type node;
test_type::iterator pos;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
test_type c0{ 1, 1, 2, 2, 3, 3 };
test_type c1 = c0, c2 = c0;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
test_type c0{ 1, 1, 2, 2, 3, 3 };
test_type c1 = c0;
std::unordered_multiset<int, hash, equal> c2( c0.begin(), c0.end() );
void
test04()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ 1, 1, 2, 2, 3, 3 };
test_type c1 = c0;
std::unordered_set<int, hash, equal> c2( c0.begin(), c0.end() );
#include <unordered_set>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
void test01()
{
const int N = 1000;
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
unordered_multiset<int> ums0;
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::unordered_multiset<int> ums1, ums2;
VERIFY( ums1 == ums2 );
VERIFY( !(ums1 != ums2) );
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef CustomPointerAlloc<T> alloc_type;
typedef std::unordered_set<T, H, E, alloc_type> test_type;
test_type v;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<T> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<counter_type, false> alloc_type;
typedef __gnu_test::counter_type_hasher hash;
typedef std::unordered_set<counter_type, hash,
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<counter_type, true> alloc_type;
typedef __gnu_test::counter_type_hasher hash;
typedef std::unordered_set<counter_type, hash,
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::unordered_set<T, hash, equal_to, alloc_type> test_type;
test_type v1(alloc_type(1));
void
test01()
{
- bool test __attribute__((unused)) = true;
-
// static_assert(std::__cache_default<int, hash>::value,
// "Unexpected default cache value");
typedef std::unordered_set<int, hash> us_t;
int main()
{
- bool test __attribute__((unused)) = true;
-
std::unordered_set<int> a,b;
a.insert(2);
b.insert(1);
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::uneq_allocator<int> alloc_type;
typedef __gnu_debug::unordered_set<int, std::hash<int>,
std::equal_to<int>, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace __gnu_debug;
std::unordered_set<int> u = { 0, 1, 2 };
void test02()
{
- bool test __attribute__((unused)) = true;
using namespace __gnu_debug;
std::unordered_set<int> u = { 0, 1, 2 };
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::propagating_allocator<int, false> alloc_type;
typedef __gnu_debug::unordered_set<int, std::hash<int>,
std::equal_to<int>,
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::unordered_set<
int, std::hash<int>, std::equal_to<int>, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_set<std::string> Set;
typedef Set::iterator iterator;
typedef Set::const_iterator const_iterator;
// libstdc++/24061
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_set<std::string> Set;
typedef Set::iterator iterator;
typedef Set::const_iterator const_iterator;
template<typename _USet>
void test()
{
- bool test __attribute__((unused)) = true;
-
for (float lf = 1.0; lf < 101.0; lf *= 10.0)
for (int size = 1; size <= 6561; size *= 3)
{
template<typename _USet>
void test(int threshold)
{
- bool test __attribute__((unused)) = true;
_USet us;
auto nb_reserved = us.bucket_count();
us.reserve(nb_reserved);
// DR 1189. Awkward interface for changing the number of buckets
// in an unordered associative container
void test01()
-{
- bool test __attribute__((unused)) = true;
-
+{
std::unordered_set<int> s1;
s1.reserve(10);
VERIFY( s1.bucket_count() >= 10 );
template<typename _USet>
void test()
{
- bool test __attribute__((unused)) = true;
{
_USet us;
for (int i = 0; i != 100000; ++i)
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::__detail::_Power2_rehash_policy policy;
VERIFY( policy._M_next_bkt(1) == 2 );
VERIFY( policy._M_next_bkt(2) == 4 );
void test02()
{
- bool test __attribute__((unused)) = true;
-
std::__detail::_Power2_rehash_policy policy;
for (std::size_t i = 1;;)
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::__detail::_Prime_rehash_policy policy;
for (std::size_t i = 1;;)
template<typename _USet>
void test()
{
- bool test __attribute__((unused)) = true;
_USet us;
typedef typename _USet::size_type size_type;
bool rehashed = false;
using namespace std;
-int test01()
+void test01()
{
- bool test __attribute__((unused)) = true;
-
unordered_set<int> m({ 1, 5, 37 });
VERIFY(m.size() == 3);
VERIFY(m.count(1) == 1);
VERIFY(m.count(102) == 1);
VERIFY(m.count(42) == 1);
VERIFY(m.count(1) == 0);
-
- return test;
}
int main()
// libstdc++/24061
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_set<std::string> Set;
typedef Set::iterator iterator;
typedef Set::const_iterator const_iterator;
typename _USet>
void test01()
{
- bool test __attribute__((unused)) = true;
-
// Make sure whatever happen we restore throw allocator limit at exit.
__gnu_cxx::limit_condition::adjustor_base adj;
typename _USet>
void test02()
{
- bool test __attribute__((unused)) = true;
-
// Make sure whatever happen we restore throw allocator limit at exit.
__gnu_cxx::limit_condition::adjustor_base adj;
#include <testsuite_hooks.h>
#include <testsuite_counter_type.h>
-bool test __attribute__((unused)) = true;
-
void test01()
{
using namespace __gnu_test;
#include <unordered_set>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
void test01()
{
typedef std::unordered_set<std::string> Set;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_set<std::string> Set;
Set s;
VERIFY(s.empty());
void test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::unordered_set<std::string> Set;
Set s;
VERIFY(s.empty());
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_set<rvalstruct> Set;
void test02()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::rvalstruct;
typedef std::unordered_set<rvalstruct> Set;
typename _USet>
void test()
{
- bool test __attribute__((unused)) = true;
-
typedef std::numeric_limits<std::size_t> nl_size_t;
_USet<int, std::hash<int>, std::equal_to<int>,
__gnu_cxx::throw_allocator_limit<int> > us;
{ return __lhs.getType() == __rhs.getType(); }
};
-bool test __attribute__((unused)) = true;
-
void test01()
{
typedef std::unordered_set<PathPoint, PathPointHasher, PathPointEqual> Set;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ 1, 2, 3 };
test_type::node_type node;
test_type::insert_return_type ins;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
test_type c{ 1, 2, 3 };
test_type::node_type node;
test_type::insert_return_type ins;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ 1, 2, 3, };
test_type c1 = c0, c2 = c0;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ 1, 2, 3, };
test_type c1 = c0;
std::unordered_set<int, hash, equal> c2( c0.begin(), c0.end() );
void
test03()
{
- bool test __attribute__((unused)) = true;
-
const test_type c0{ 1, 2, 3, };
test_type c1 = c0;
std::unordered_multiset<int, hash, equal> c2( c0.begin(), c0.end() );
#include <unordered_set>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
void test01()
{
const int N = 1000;
void test01()
{
- bool test __attribute__((unused)) = true;
std::unordered_set<int> us1 { 0, 1 };
{
std::unordered_set<int> us2(std::move(us1));
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
unordered_set<int> us0;
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::unordered_set<int> us1, us2;
VERIFY( us1 == us2 );
VERIFY( !(us1 != us2) );
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef CustomPointerAlloc<T> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef SimpleAllocator<T> alloc_type;
typedef std::allocator_traits<alloc_type> traits_type;
typedef std::vector<T, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
// libstdc++/6886
void test02()
{
- bool test __attribute__((unused)) = true;
typedef std::vector<bool> bvec;
int i, num = 0;
bvec v;
void
test01()
{
- bool test __attribute((unused)) = true;
-
typedef bool value_type;
typedef __gnu_cxx::throw_allocator_limit<value_type> allocator_type;
typedef std::vector<value_type, allocator_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef CustomPointerAlloc<T> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v;
void test01()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef uneq_allocator<T> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test03()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test01()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, false> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void test02()
{
- bool test __attribute__((unused)) = true;
typedef propagating_allocator<T, true> alloc_type;
typedef std::vector<T, alloc_type> test_type;
test_type v1(alloc_type(1));
void
test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::vector<bool> vec_type;
vec_type v;
// libstdc++/29134
void test01()
{
- bool test __attribute__((unused)) = true;
-
using std::vector;
using std::numeric_limits;
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<bool> vb(__CHAR_BIT__ * sizeof(unsigned long) + 1);
vb.pop_back();
void
test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::vector<bool> vec_type;
const vec_type v1_ref(A1, A1 + N1);
void
test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::vector<bool> vec_type;
vec_type v1;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::vector<bool> vec_type;
typedef vec_type::iterator iterator_type;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::vector<std::vector<bool> > vec_type;
typedef vec_type::iterator iterator_type;
void
test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::vector<bool> vec_type;
vec_type v;
// libstdc++/31370
void test01()
{
- bool test __attribute__((unused)) = true;
int myexit = 0;
try
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef __gnu_test::uneq_allocator<bool> my_alloc;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef __gnu_test::uneq_allocator<bool> my_alloc;
void
my_compare(const Cont& c1, const Cont& c2)
{
- bool test __attribute__((unused)) = true;
-
VERIFY( c1.size() == c2.size() );
for (std::size_t i = 0; i < c1.size(); ++i)
void test01()
{
// non POD types
- bool test __attribute__((unused)) = true;
std::vector< A<B> > vec01;
typedef std::vector< A<B> >::size_type size_type;
void
test_reserve()
{
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
void
test_reserve_exception_guarantee()
{
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
// libstdc++/29134
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
vector<int> v;
// libstdc++/29134
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<int> v;
VERIFY( v.max_size() == v.get_allocator().max_size() );
// libstdc++/44190
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<int> v;
v.resize(10);
VERIFY( v.size() <= v.capacity() );
// libstdc++/8230
void test02()
{
- bool test __attribute__((unused)) = true;
+ bool test = true;
{
std::vector<int> array;
const std::size_t size = array.max_size();
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace __gnu_test;
std::vector<copycounter> a(40);
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace __gnu_test;
std::vector<throwing_move_constructor> v(5);
void test01()
{
- bool test __attribute__((unused)) = true;
+ bool test = true;
std::vector<int> v;
try
{
void
test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<copycounter> a;
copycounter::copycount = 0;
a.resize(10);
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace __gnu_test;
std::vector<throwing_move_constructor> v(5);
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<__gnu_test::NonCopyConstructible> v;
VERIFY( std::distance(v.begin(), v.end()) == 0 );
// libstdc++/42573
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<int> v(100);
v.push_back(1);
v.push_back(1);
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef propagating_allocator<int, true> alloc_type;
alloc_type alloc(5);
void test02()
{
- bool test __attribute__((unused)) = true;
-
typedef propagating_allocator<int, false> alloc_type;
alloc_type alloc(5);
void
test03()
{
- bool test __attribute__((unused)) = true;
const int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
const int B[] = {7, 7, 7, 7, 7};
const int N = sizeof(A) / sizeof(int);
test_default_ctor_exception_gurantee()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_copy_ctor_exception_gurantee()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_assignment_operator_1()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_assignment_operator_2()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_assignment_operator_3()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_assignment_operator_3_exception_guarantee()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_fill_assign_1()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_fill_assign_2()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_fill_assign_3()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_fill_assign_3_exception_guarantee()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_fill_assign_4()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_range_assign_2()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_range_assign_3()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_range_assign_4()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
test_range_assign_4_exception_guarantee()
{
// setup
- bool test __attribute__((unused)) = true;
typedef copy_tracker T;
typedef std::vector<T, tracker_allocator<T> > X;
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<__gnu_test::NonCopyConstructible> v(1000);
VERIFY( std::distance(v.begin(), v.end()) == 1000 );
for(auto it = v.begin(); it != v.end(); ++it)
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<int> a,b;
a.push_back(1);
b = std::move(a);
void test02()
{
- bool test __attribute__((unused)) = true;
-
std::vector<bool> a,b;
a.push_back(1);
b = std::move(a);
// libstdc++/23578
void test01()
-{
- bool test __attribute__((unused)) = true;
+{
typedef std::vector<int> vector_type;
{
void test01()
{
- bool test __attribute__((unused)) = true;
using namespace __gnu_debug;
std::vector<int> v1(3, 1);
void test02()
{
- bool test __attribute__((unused)) = true;
using namespace __gnu_debug;
std::vector<int> v1(3, 1);
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_test::propagating_allocator<int, false> alloc_type;
typedef __gnu_debug::vector<int, alloc_type> test_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
typedef uneq_allocator<int> alloc_type;
typedef __gnu_debug::vector<int, alloc_type> test_type;
void test01()
{
using namespace std;
- bool test __attribute__((unused)) = true;
vector<int> v1, v2;
vector<shared_ptr<vector<int> > > vs;
vector<int> *pv3 = 0, *pv4 = 0;
struct B { };
// http://gcc.gnu.org/ml/libstdc++/2000-09/msg00002.html
-bool test01()
+void test01()
{
- bool test __attribute__((unused)) = true;
std::vector< A<B> > vec01;
std::vector< A<B> > vec02(5);
typedef std::vector< A<B> >::size_type size_type;
{
VERIFY( false );
}
- return test;
}
int main()
void
test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<int, __gnu_cxx::_ExtPtr_allocator<int> > v(7);
VERIFY( v.cbegin() == v.begin() );
VERIFY( v.cend() == v.end() );
// libstdc++/23578
void test01()
-{
- bool test __attribute__((unused)) = true;
+{
typedef std::vector<int, __gnu_cxx::_ExtPtr_allocator<int> > vector_type;
{
// General tests element access and manipulation
void test01()
{
- bool test __attribute__((unused)) = true;
-
int A[] = { 0, 1, 2, 3, 4 };
__gnu_cxx::_ExtPtr_allocator<int> alloc;
std::vector<int,__gnu_cxx::_ExtPtr_allocator<int> > mv( A, A+5, alloc );
void
test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::vector<int,__gnu_cxx::_ExtPtr_allocator<int> > vec_type;
typedef vec_type::iterator iterator_type;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
typedef __gnu_cxx::_ExtPtr_allocator<int> int_alloc_type;
typedef __gnu_cxx::_ExtPtr_allocator< std::vector<int, int_alloc_type> > vec_alloc_type;
typedef std::vector<std::vector<int, int_alloc_type >,vec_alloc_type> vec_type;
void test01()
{
- bool test __attribute__((unused)) = true;
-
__gnu_cxx::_ExtPtr_allocator<int> alloc;
std::vector<int, __gnu_cxx::_ExtPtr_allocator<int> > iv(alloc);
VERIFY( iv.get_allocator() == alloc );
void test01()
{
// non POD types
- bool test __attribute__((unused)) = true;
-
std::vector<int, __gnu_cxx::_ExtPtr_allocator<int> > vec01;
typedef std::vector<int, __gnu_cxx::_ExtPtr_allocator<int> >::size_type size_type;
#include <vector>
#include "testsuite_hooks.h"
-bool test __attribute__((unused)) = true;
-
template<typename T>
struct A { };
#include <vector>
#include "testsuite_hooks.h"
-bool test __attribute__((unused)) = true;
-
// test the assign() function
void
test03()
const int B[] = {K, K, K, K, K};
const std::size_t N = sizeof(A) / sizeof(int);
const std::size_t M = sizeof(B) / sizeof(int);
- bool test __attribute__((unused)) = true;
// assign from pointer range
std::vector<int> v3;
#include <vector>
#include "testsuite_hooks.h"
-bool test __attribute__((unused)) = true;
-
void
test01()
{
void
test01()
{
- bool test __attribute__((unused)) = true;
-
typedef std::vector<int> vec_type;
typedef vec_type::iterator iterator_type;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
typedef std::vector<std::vector<int> > vec_type;
typedef vec_type::iterator iterator_type;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace __gnu_test;
std::vector<copycounter> a(40);
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
vector<int> iv;
#include "testsuite_hooks.h"
-bool test __attribute__((unused)) = true;
-
void test01()
{
std::vector<std::vector<int>> vv =
void
test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<copycounter> a;
copycounter c(1);
copycounter::copycount = 0;
void
test02()
{
- bool test __attribute__((unused)) = true;
-
copycounter c(1);
std::vector<copycounter> a(10, c), b(100, c);
copycounter::copycount = 0;
void
test03()
{
- bool test __attribute__((unused)) = true;
-
copycounter c(1);
std::vector<copycounter> a(10, c), b(100, c);
copycounter::copycount = 0;
void
test04()
{
- bool test __attribute__((unused)) = true;
-
copycounter c(1);
std::vector<copycounter> a(10, c);
copycounter::copycount = 0;
void
test05()
{
- bool test __attribute__((unused)) = true;
-
copycounter c(1);
std::vector<copycounter> a(10, c);
copycounter::copycount = 0;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace __gnu_test;
std::vector<throwing_move_constructor> v1;
// libstdc++/49836
void test01()
{
- bool test __attribute__((unused)) = true;
using __gnu_test::CopyConsOnlyType;
using __gnu_test::MoveConsOnlyType;
// Should use vector specialization for swap.
void test01()
{
- bool test __attribute__((unused)) = true;
std::vector<T> A;
std::vector<T> B;
swap_calls = 0;
// Should use vector specialization for swap.
void test02()
{
- bool test __attribute__((unused)) = true;
using namespace std;
vector<T> A;
vector<T> B;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef __gnu_test::uneq_allocator<char> my_alloc;
void
test01()
{
- bool test __attribute__((unused)) = true;
using namespace std;
typedef __gnu_test::uneq_allocator<char> my_alloc;
// http://gcc.gnu.org/ml/libstdc++/2007-09/msg00006.html
void test01()
{
- bool test __attribute__((unused)) = true;
-
std::vector<std::vector<int> > *v;
VERIFY( zero_sized_news == 0 );