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 // <deque>
10
11 // explicit deque(size_type n);
12
13 #include <deque>
14 #include <cassert>
15 #include <cstddef>
16
17 #include "test_macros.h"
18 #include "test_allocator.h"
19 #include "DefaultOnly.h"
20 #include "min_allocator.h"
21
22 template <class T, class Allocator>
23 void
test2(unsigned n)24 test2(unsigned n)
25 {
26 #if TEST_STD_VER > 11
27 typedef std::deque<T, Allocator> C;
28 typedef typename C::const_iterator const_iterator;
29 assert(DefaultOnly::count == 0);
30 {
31 C d(n, Allocator());
32 assert(static_cast<unsigned>(DefaultOnly::count) == n);
33 assert(d.size() == n);
34 assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
35 for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
36 assert(*i == T());
37 }
38 assert(DefaultOnly::count == 0);
39 #else
40 ((void)n);
41 #endif
42 }
43
44 template <class T, class Allocator>
45 void
test1(unsigned n)46 test1(unsigned n)
47 {
48 typedef std::deque<T, Allocator> C;
49 typedef typename C::const_iterator const_iterator;
50 assert(DefaultOnly::count == 0);
51 {
52 C d(n);
53 assert(static_cast<unsigned>(DefaultOnly::count) == n);
54 assert(d.size() == n);
55 assert(static_cast<std::size_t>(distance(d.begin(), d.end())) == d.size());
56 #if TEST_STD_VER >= 11
57 for (const_iterator i = d.begin(), e = d.end(); i != e; ++i)
58 assert(*i == T());
59 #endif
60 }
61 assert(DefaultOnly::count == 0);
62 }
63
64 template <class T, class Allocator>
65 void
test3(unsigned n,Allocator const & alloc=Allocator ())66 test3(unsigned n, Allocator const &alloc = Allocator())
67 {
68 #if TEST_STD_VER > 11
69 typedef std::deque<T, Allocator> C;
70 {
71 C d(n, alloc);
72 assert(d.size() == n);
73 assert(d.get_allocator() == alloc);
74 }
75 #else
76 ((void)n);
77 ((void)alloc);
78 #endif
79 }
80
81 template <class T, class Allocator>
82 void
test(unsigned n)83 test(unsigned n)
84 {
85 test1<T, Allocator> ( n );
86 test2<T, Allocator> ( n );
87 }
88
main(int,char **)89 int main(int, char**)
90 {
91 test<DefaultOnly, std::allocator<DefaultOnly> >(0);
92 test<DefaultOnly, std::allocator<DefaultOnly> >(1);
93 test<DefaultOnly, std::allocator<DefaultOnly> >(10);
94 test<DefaultOnly, std::allocator<DefaultOnly> >(1023);
95 test<DefaultOnly, std::allocator<DefaultOnly> >(1024);
96 test<DefaultOnly, std::allocator<DefaultOnly> >(1025);
97 test<DefaultOnly, std::allocator<DefaultOnly> >(2047);
98 test<DefaultOnly, std::allocator<DefaultOnly> >(2048);
99 test<DefaultOnly, std::allocator<DefaultOnly> >(2049);
100 test<DefaultOnly, std::allocator<DefaultOnly> >(4095);
101 test<DefaultOnly, std::allocator<DefaultOnly> >(4096);
102 test<DefaultOnly, std::allocator<DefaultOnly> >(4097);
103
104 LIBCPP_ONLY(test1<DefaultOnly, limited_allocator<DefaultOnly, 4096> >(4095));
105
106 #if TEST_STD_VER >= 11
107 test<DefaultOnly, min_allocator<DefaultOnly> >(4095);
108 #endif
109
110 #if TEST_STD_VER > 11
111 test3<DefaultOnly, std::allocator<DefaultOnly>> (1023);
112 test3<int, std::allocator<int>>(1);
113 test3<int, min_allocator<int>> (3);
114 #endif
115
116
117 return 0;
118 }
119