1 /*
2 * Copyright (C) 2011 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23 * THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26 #include "config.h"
27
28 #include "wtf/Deque.h"
29
30 #include "wtf/HashSet.h"
31 #include "wtf/OwnPtr.h"
32 #include "wtf/PassOwnPtr.h"
33 #include <gtest/gtest.h>
34
35 namespace {
36
TEST(DequeTest,Basic)37 TEST(DequeTest, Basic)
38 {
39 Deque<int> intDeque;
40 EXPECT_TRUE(intDeque.isEmpty());
41 EXPECT_EQ(0ul, intDeque.size());
42 }
43
checkNumberSequence(Deque<int> & deque,int from,int to,bool increment)44 void checkNumberSequence(Deque<int>& deque, int from, int to, bool increment)
45 {
46 Deque<int>::iterator it = increment ? deque.begin() : deque.end();
47 int step = from < to ? 1 : -1;
48 for (int i = from; i != to + step; i += step) {
49 if (!increment)
50 --it;
51
52 EXPECT_EQ(i, *it);
53
54 if (increment)
55 ++it;
56 }
57 EXPECT_EQ(increment ? deque.end() : deque.begin(), it);
58 }
59
checkNumberSequenceReverse(Deque<int> & deque,int from,int to,bool increment)60 void checkNumberSequenceReverse(Deque<int>& deque, int from, int to, bool increment)
61 {
62 Deque<int>::reverse_iterator it = increment ? deque.rbegin() : deque.rend();
63 int step = from < to ? 1 : -1;
64 for (int i = from; i != to + step; i += step) {
65 if (!increment)
66 --it;
67
68 EXPECT_EQ(i, *it);
69
70 if (increment)
71 ++it;
72 }
73 EXPECT_EQ(increment ? deque.rend() : deque.rbegin(), it);
74 }
75
TEST(DequeTest,Reverse)76 TEST(DequeTest, Reverse)
77 {
78 Deque<int> intDeque;
79 intDeque.append(10);
80 intDeque.append(11);
81 intDeque.append(12);
82 intDeque.append(13);
83
84 checkNumberSequence(intDeque, 10, 13, true);
85 checkNumberSequence(intDeque, 13, 10, false);
86 checkNumberSequenceReverse(intDeque, 13, 10, true);
87 checkNumberSequenceReverse(intDeque, 10, 13, false);
88
89 intDeque.append(14);
90 intDeque.append(15);
91 EXPECT_EQ(10, intDeque.takeFirst());
92 EXPECT_EQ(15, intDeque.takeLast());
93 checkNumberSequence(intDeque, 11, 14, true);
94 checkNumberSequence(intDeque, 14, 11, false);
95 checkNumberSequenceReverse(intDeque, 14, 11, true);
96 checkNumberSequenceReverse(intDeque, 11, 14, false);
97
98 for (int i = 15; i < 200; ++i)
99 intDeque.append(i);
100 checkNumberSequence(intDeque, 11, 199, true);
101 checkNumberSequence(intDeque, 199, 11, false);
102 checkNumberSequenceReverse(intDeque, 199, 11, true);
103 checkNumberSequenceReverse(intDeque, 11, 199, false);
104
105 for (int i = 0; i < 180; ++i)
106 EXPECT_EQ(i + 11, intDeque.takeFirst());
107 checkNumberSequence(intDeque, 191, 199, true);
108 checkNumberSequence(intDeque, 199, 191, false);
109 checkNumberSequenceReverse(intDeque, 199, 191, true);
110 checkNumberSequenceReverse(intDeque, 191, 199, false);
111
112 Deque<int> intDeque2;
113 swap(intDeque, intDeque2);
114
115 checkNumberSequence(intDeque2, 191, 199, true);
116 checkNumberSequence(intDeque2, 199, 191, false);
117 checkNumberSequenceReverse(intDeque2, 199, 191, true);
118 checkNumberSequenceReverse(intDeque2, 191, 199, false);
119
120 intDeque.swap(intDeque2);
121
122 checkNumberSequence(intDeque, 191, 199, true);
123 checkNumberSequence(intDeque, 199, 191, false);
124 checkNumberSequenceReverse(intDeque, 199, 191, true);
125 checkNumberSequenceReverse(intDeque, 191, 199, false);
126
127 intDeque.swap(intDeque2);
128
129 checkNumberSequence(intDeque2, 191, 199, true);
130 checkNumberSequence(intDeque2, 199, 191, false);
131 checkNumberSequenceReverse(intDeque2, 199, 191, true);
132 checkNumberSequenceReverse(intDeque2, 191, 199, false);
133 }
134
135 class DestructCounter {
136 public:
DestructCounter(int i,int * destructNumber)137 explicit DestructCounter(int i, int* destructNumber)
138 : m_i(i)
139 , m_destructNumber(destructNumber)
140 { }
141
~DestructCounter()142 ~DestructCounter() { ++(*m_destructNumber); }
get() const143 int get() const { return m_i; }
144
145 private:
146 int m_i;
147 int* m_destructNumber;
148 };
149
150 typedef WTF::Deque<OwnPtr<DestructCounter> > OwnPtrDeque;
151
TEST(DequeTest,OwnPtr)152 TEST(DequeTest, OwnPtr)
153 {
154 int destructNumber = 0;
155 OwnPtrDeque deque;
156 deque.append(adoptPtr(new DestructCounter(0, &destructNumber)));
157 deque.append(adoptPtr(new DestructCounter(1, &destructNumber)));
158 EXPECT_EQ(2u, deque.size());
159
160 OwnPtr<DestructCounter>& counter0 = deque.first();
161 EXPECT_EQ(0, counter0->get());
162 int counter1 = deque.last()->get();
163 EXPECT_EQ(1, counter1);
164 EXPECT_EQ(0, destructNumber);
165
166 size_t index = 0;
167 for (OwnPtrDeque::iterator iter = deque.begin(); iter != deque.end(); ++iter) {
168 OwnPtr<DestructCounter>& refCounter = *iter;
169 EXPECT_EQ(index, static_cast<size_t>(refCounter->get()));
170 EXPECT_EQ(index, static_cast<size_t>((*refCounter).get()));
171 index++;
172 }
173 EXPECT_EQ(0, destructNumber);
174
175 OwnPtrDeque::iterator it = deque.begin();
176 for (index = 0; index < deque.size(); ++index) {
177 OwnPtr<DestructCounter>& refCounter = *it;
178 EXPECT_EQ(index, static_cast<size_t>(refCounter->get()));
179 index++;
180 ++it;
181 }
182 EXPECT_EQ(0, destructNumber);
183
184 EXPECT_EQ(0, deque.first()->get());
185 deque.removeFirst();
186 EXPECT_EQ(1, deque.first()->get());
187 EXPECT_EQ(1u, deque.size());
188 EXPECT_EQ(1, destructNumber);
189
190 OwnPtr<DestructCounter> ownCounter1 = deque.first().release();
191 deque.removeFirst();
192 EXPECT_EQ(counter1, ownCounter1->get());
193 EXPECT_EQ(0u, deque.size());
194 EXPECT_EQ(1, destructNumber);
195
196 ownCounter1.clear();
197 EXPECT_EQ(2, destructNumber);
198
199 size_t count = 1025;
200 destructNumber = 0;
201 for (size_t i = 0; i < count; ++i)
202 deque.prepend(adoptPtr(new DestructCounter(i, &destructNumber)));
203
204 // Deque relocation must not destruct OwnPtr element.
205 EXPECT_EQ(0, destructNumber);
206 EXPECT_EQ(count, deque.size());
207
208 OwnPtrDeque copyDeque;
209 deque.swap(copyDeque);
210 EXPECT_EQ(0, destructNumber);
211 EXPECT_EQ(count, copyDeque.size());
212 EXPECT_EQ(0u, deque.size());
213
214 copyDeque.clear();
215 EXPECT_EQ(count, static_cast<size_t>(destructNumber));
216 }
217
218 // WrappedInt class will fail if it was memmoved or memcpyed.
219 static HashSet<void*> constructedWrappedInts;
220 class WrappedInt {
221 public:
WrappedInt(int i=0)222 WrappedInt(int i = 0)
223 : m_originalThisPtr(this)
224 , m_i(i)
225 {
226 constructedWrappedInts.add(this);
227 }
228
WrappedInt(const WrappedInt & other)229 WrappedInt(const WrappedInt& other)
230 : m_originalThisPtr(this)
231 , m_i(other.m_i)
232 {
233 constructedWrappedInts.add(this);
234 }
235
operator =(const WrappedInt & other)236 WrappedInt& operator=(const WrappedInt& other)
237 {
238 m_i = other.m_i;
239 return *this;
240 }
241
~WrappedInt()242 ~WrappedInt()
243 {
244 EXPECT_EQ(m_originalThisPtr, this);
245 EXPECT_TRUE(constructedWrappedInts.contains(this));
246 constructedWrappedInts.remove(this);
247 }
248
get() const249 int get() const { return m_i; }
250
251 private:
252 void* m_originalThisPtr;
253 int m_i;
254 };
255
TEST(DequeTest,SwapWithoutInlineCapacity)256 TEST(DequeTest, SwapWithoutInlineCapacity)
257 {
258 Deque<WrappedInt> dequeA;
259 dequeA.append(WrappedInt(1));
260 Deque<WrappedInt> dequeB;
261 dequeB.append(WrappedInt(2));
262
263 ASSERT_EQ(dequeA.size(), dequeB.size());
264 dequeA.swap(dequeB);
265
266 ASSERT_EQ(1u, dequeA.size());
267 EXPECT_EQ(2, dequeA.first().get());
268 ASSERT_EQ(1u, dequeB.size());
269 EXPECT_EQ(1, dequeB.first().get());
270
271 dequeA.append(WrappedInt(3));
272
273 ASSERT_GT(dequeA.size(), dequeB.size());
274 dequeA.swap(dequeB);
275
276 ASSERT_EQ(1u, dequeA.size());
277 EXPECT_EQ(1, dequeA.first().get());
278 ASSERT_EQ(2u, dequeB.size());
279 EXPECT_EQ(2, dequeB.first().get());
280
281 ASSERT_LT(dequeA.size(), dequeB.size());
282 dequeA.swap(dequeB);
283
284 ASSERT_EQ(2u, dequeA.size());
285 EXPECT_EQ(2, dequeA.first().get());
286 ASSERT_EQ(1u, dequeB.size());
287 EXPECT_EQ(1, dequeB.first().get());
288
289 dequeA.append(WrappedInt(4));
290 dequeA.swap(dequeB);
291
292 ASSERT_EQ(1u, dequeA.size());
293 EXPECT_EQ(1, dequeA.first().get());
294 ASSERT_EQ(3u, dequeB.size());
295 EXPECT_EQ(2, dequeB.first().get());
296
297 dequeB.swap(dequeA);
298 }
299
300 } // namespace
301