1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// UNSUPPORTED: c++03
10
11// <deque>
12
13// deque(deque&& c, const allocator_type& a);
14
15#include "asan_testing.h"
16#include <deque>
17#include <cassert>
18
19#include "test_macros.h"
20#include "MoveOnly.h"
21#include "test_allocator.h"
22#include "min_allocator.h"
23
24int main(int, char**) {
25 {
26 int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
27 const int* an = ab + sizeof(ab) / sizeof(ab[0]);
28 typedef test_allocator<MoveOnly> A;
29 std::deque<MoveOnly, A> c1(A(1));
30 for (int* p = ab; p < an; ++p)
31 c1.push_back(MoveOnly(*p));
32 std::deque<MoveOnly, A> c2(A(1));
33 for (int* p = ab; p < an; ++p)
34 c2.push_back(MoveOnly(*p));
35 std::deque<MoveOnly, A> c3(std::move(c1), A(3)); // unequal allocator
36 assert(c2 == c3);
37 assert(c3.get_allocator() == A(3));
38 LIBCPP_ASSERT(c1.size() != 0);
39 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
40 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
41 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
42 }
43 {
44 int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
45 const int* an = ab + sizeof(ab) / sizeof(ab[0]);
46 typedef test_allocator<MoveOnly> A;
47 std::deque<MoveOnly, A> c1(A(1));
48 for (int* p = ab; p < an; ++p)
49 c1.push_back(MoveOnly(*p));
50 std::deque<MoveOnly, A> c2(A(1));
51 for (int* p = ab; p < an; ++p)
52 c2.push_back(MoveOnly(*p));
53 std::deque<MoveOnly, A> c3(std::move(c1), A(1)); // equal allocator
54 assert(c2 == c3);
55 assert(c3.get_allocator() == A(1));
56 LIBCPP_ASSERT(c1.size() == 0);
57 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
58 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
59 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
60 }
61 {
62 int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
63 const int* an = ab + sizeof(ab) / sizeof(ab[0]);
64 typedef other_allocator<MoveOnly> A;
65 std::deque<MoveOnly, A> c1(A(1));
66 for (int* p = ab; p < an; ++p)
67 c1.push_back(MoveOnly(*p));
68 std::deque<MoveOnly, A> c2(A(1));
69 for (int* p = ab; p < an; ++p)
70 c2.push_back(MoveOnly(*p));
71 std::deque<MoveOnly, A> c3(std::move(c1), A(3)); // unequal allocator
72 assert(c2 == c3);
73 assert(c3.get_allocator() == A(3));
74 LIBCPP_ASSERT(c1.size() != 0);
75 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
76 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
77 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
78 }
79 {
80 int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
81 const int* an = ab + sizeof(ab) / sizeof(ab[0]);
82 typedef min_allocator<MoveOnly> A;
83 std::deque<MoveOnly, A> c1(A{});
84 for (int* p = ab; p < an; ++p)
85 c1.push_back(MoveOnly(*p));
86 std::deque<MoveOnly, A> c2(A{});
87 for (int* p = ab; p < an; ++p)
88 c2.push_back(MoveOnly(*p));
89 std::deque<MoveOnly, A> c3(std::move(c1), A()); // equal allocator
90 assert(c2 == c3);
91 assert(c3.get_allocator() == A());
92 LIBCPP_ASSERT(c1.size() == 0);
93 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c1));
94 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c2));
95 LIBCPP_ASSERT(is_double_ended_contiguous_container_asan_correct(c3));
96 }
97
98 return 0;
99}
100

source code of libcxx/test/std/containers/sequences/deque/deque.cons/move_alloc.pass.cpp