1 /*-------------------------------------------------------------------------
2 * drawElements C++ Base Library
3 * -----------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Shared pointer.
22 *//*--------------------------------------------------------------------*/
23
24 #include "deSharedPtr.hpp"
25 #include "deThread.hpp"
26 #include "deClock.h"
27
28 #include <exception>
29
30 namespace de
31 {
32
33 namespace
34 {
35
36 enum
37 {
38 THREAD_TEST_TIME = 200*1000
39 };
40
41 class Object
42 {
43 public:
Object(bool & exists)44 Object (bool& exists)
45 : m_exists(exists)
46 {
47 m_exists = true;
48 }
49
~Object(void)50 virtual ~Object (void)
51 {
52 m_exists = false;
53 }
54
55 private:
56 bool& m_exists;
57 };
58
59 class DerivedObject : public Object
60 {
61 public:
DerivedObject(bool & exists)62 DerivedObject (bool& exists)
63 : Object(exists)
64 {
65 }
66 };
67
68 class SharedPtrTestThread : public Thread
69 {
70 public:
SharedPtrTestThread(const SharedPtr<Object> & ptr,const bool & exists)71 SharedPtrTestThread (const SharedPtr<Object>& ptr, const bool& exists)
72 : m_ptr (ptr)
73 , m_exists (exists)
74 {
75 }
76
run(void)77 void run (void)
78 {
79 deUint64 startTime = deGetMicroseconds();
80 deUint64 cnt = 0;
81
82 for (;; cnt++)
83 {
84 if (((cnt&(1<<14)) != 0) && (deGetMicroseconds()-startTime >= THREAD_TEST_TIME))
85 break;
86
87 {
88 SharedPtr<Object> ptrA(m_ptr);
89 {
90 SharedPtr<Object> ptrB;
91 ptrB = ptrA;
92 ptrA = SharedPtr<Object>();
93 }
94 }
95 DE_TEST_ASSERT(m_exists);
96 }
97 }
98
99 private:
100 SharedPtr<Object> m_ptr;
101 const bool& m_exists;
102 };
103
104 class WeakPtrTestThread : public Thread
105 {
106 public:
WeakPtrTestThread(const SharedPtr<Object> & ptr,const bool & exists)107 WeakPtrTestThread (const SharedPtr<Object>& ptr, const bool& exists)
108 : m_ptr (ptr)
109 , m_exists (exists)
110 {
111 }
112
run(void)113 void run (void)
114 {
115 deUint64 startTime = deGetMicroseconds();
116 deUint64 cnt = 0;
117
118 for (;; cnt++)
119 {
120 if (((cnt&(1<<14)) != 0) && (deGetMicroseconds()-startTime >= THREAD_TEST_TIME))
121 break;
122
123 {
124 WeakPtr<Object> ptrA(m_ptr);
125 {
126 WeakPtr<Object> ptrB;
127 ptrB = ptrA;
128 ptrA = SharedPtr<Object>();
129 }
130 }
131 DE_TEST_ASSERT(m_exists);
132 }
133 }
134
135 private:
136 SharedPtr<Object> m_ptr;
137 const bool& m_exists;
138 };
139
makeObject(bool & exists)140 SharedPtr<Object> makeObject (bool& exists)
141 {
142 return SharedPtr<Object>(new Object(exists));
143 }
144
145 struct CustomDeleter
146 {
CustomDeleterde::__anon2602130c0111::CustomDeleter147 CustomDeleter (bool* called) : m_called(called) {}
148
operator ()de::__anon2602130c0111::CustomDeleter149 void operator() (Object* ptr)
150 {
151 DE_TEST_ASSERT(!*m_called);
152 delete ptr;
153 *m_called = true;
154 }
155
156 bool* m_called;
157 };
158
159 } // anonymous
160
SharedPtr_selfTest(void)161 void SharedPtr_selfTest (void)
162 {
163 // Empty pointer test.
164 {
165 SharedPtr<Object> ptr;
166 DE_TEST_ASSERT(ptr.get() == DE_NULL);
167 DE_TEST_ASSERT(!ptr);
168 }
169
170 // Empty pointer copy.
171 {
172 SharedPtr<Object> ptrA;
173 SharedPtr<Object> ptrB(ptrA);
174 DE_TEST_ASSERT(ptrB.get() == DE_NULL);
175 }
176
177 // Empty pointer assignment.
178 {
179 SharedPtr<Object> ptrA;
180 SharedPtr<Object> ptrB;
181 ptrB = ptrA;
182 ptrB = ptrB;
183 }
184
185 // Basic test.
186 {
187 bool exists = false;
188 {
189 SharedPtr<Object> ptr(new Object(exists));
190 DE_TEST_ASSERT(exists);
191 DE_TEST_ASSERT(ptr.get() != DE_NULL);
192 DE_TEST_ASSERT(ptr);
193 }
194 DE_TEST_ASSERT(!exists);
195 }
196
197 // Exception test.
198 {
199 bool exists = false;
200 try
201 {
202 SharedPtr<Object> ptr(new Object(exists));
203 DE_TEST_ASSERT(exists);
204 DE_TEST_ASSERT(ptr.get() != DE_NULL);
205 throw std::exception();
206 }
207 catch (const std::exception&)
208 {
209 DE_TEST_ASSERT(!exists);
210 }
211 DE_TEST_ASSERT(!exists);
212 }
213
214 // Expression test.
215 {
216 bool exists = false;
217 bool test = (SharedPtr<Object>(new Object(exists))).get() != DE_NULL && exists;
218 DE_TEST_ASSERT(!exists);
219 DE_TEST_ASSERT(test);
220 }
221
222 // Assignment test.
223 {
224 bool exists = false;
225 SharedPtr<Object> ptr(new Object(exists));
226 DE_TEST_ASSERT(exists);
227 ptr = SharedPtr<Object>();
228 DE_TEST_ASSERT(!exists);
229 }
230
231 // Self-assignment test.
232 {
233 bool exists = false;
234 {
235 SharedPtr<Object> ptr(new Object(exists));
236 DE_TEST_ASSERT(exists);
237 DE_TEST_ASSERT(ptr.get() != DE_NULL);
238 ptr = ptr;
239 }
240 DE_TEST_ASSERT(!exists);
241 }
242
243 // Basic multi-reference via copy ctor.
244 {
245 bool exists = false;
246 {
247 SharedPtr<Object> ptrA(new Object(exists));
248 DE_TEST_ASSERT(exists);
249 {
250 SharedPtr<Object> ptrB(ptrA);
251 DE_TEST_ASSERT(exists);
252 }
253 DE_TEST_ASSERT(exists);
254 }
255 DE_TEST_ASSERT(!exists);
256 }
257
258 // Basic multi-reference via assignment to empty.
259 {
260 bool exists = false;
261 {
262 SharedPtr<Object> ptrA(new Object(exists));
263 DE_TEST_ASSERT(exists);
264 {
265 SharedPtr<Object> ptrB;
266 ptrB = ptrA;
267 DE_TEST_ASSERT(exists);
268 }
269 DE_TEST_ASSERT(exists);
270 }
271 DE_TEST_ASSERT(!exists);
272 }
273
274 // Multi-reference via assignment to non-empty.
275 {
276 bool existsA = false;
277 bool existsB = false;
278 {
279 SharedPtr<Object> ptrA(new Object(existsA));
280 DE_TEST_ASSERT(existsA);
281 {
282 SharedPtr<Object> ptrB(new Object(existsB));
283 DE_TEST_ASSERT(existsB);
284 ptrA = ptrB;
285 DE_TEST_ASSERT(!existsA);
286 DE_TEST_ASSERT(existsB);
287 }
288 DE_TEST_ASSERT(existsB);
289 }
290 DE_TEST_ASSERT(!existsB);
291 }
292
293 // Return from function.
294 {
295 bool exists = false;
296 {
297 SharedPtr<Object> ptr;
298 ptr = makeObject(exists);
299 DE_TEST_ASSERT(exists);
300 }
301 DE_TEST_ASSERT(!exists);
302 }
303
304 // Equality comparison.
305 {
306 bool existsA = false;
307 bool existsB = false;
308 SharedPtr<Object> ptrA(new Object(existsA));
309 SharedPtr<Object> ptrB(new Object(existsB));
310 SharedPtr<Object> ptrC(ptrA);
311
312 DE_TEST_ASSERT(ptrA == ptrA);
313 DE_TEST_ASSERT(ptrA != ptrB);
314 DE_TEST_ASSERT(ptrA == ptrC);
315 DE_TEST_ASSERT(ptrC != ptrB);
316 }
317
318 // Conversion via assignment.
319 {
320 bool exists = false;
321 {
322 SharedPtr<Object> basePtr;
323 {
324 SharedPtr<DerivedObject> derivedPtr(new DerivedObject(exists));
325 DE_TEST_ASSERT(exists);
326 basePtr = derivedPtr;
327 DE_TEST_ASSERT(exists);
328 }
329 DE_TEST_ASSERT(exists);
330 }
331 DE_TEST_ASSERT(!exists);
332 }
333
334 // Conversion via copy ctor.
335 {
336 bool exists = false;
337 {
338 SharedPtr<DerivedObject> derivedPtr (new DerivedObject(exists));
339 SharedPtr<Object> basePtr (derivedPtr);
340 DE_TEST_ASSERT(exists);
341 derivedPtr = SharedPtr<DerivedObject>();
342 DE_TEST_ASSERT(exists);
343 }
344 DE_TEST_ASSERT(!exists);
345 }
346
347 // Explicit conversion operator.
348 {
349 bool exists = false;
350 {
351 SharedPtr<DerivedObject> derivedPtr (new DerivedObject(exists));
352 DE_TEST_ASSERT(exists);
353
354 SharedPtr<Object> basePtr = (SharedPtr<Object>)(derivedPtr);
355 derivedPtr = SharedPtr<DerivedObject>();
356 DE_TEST_ASSERT(exists);
357 }
358 DE_TEST_ASSERT(!exists);
359 }
360
361 // Basic weak reference.
362 {
363 bool exists = false;
364 SharedPtr<Object> ptr(new Object(exists));
365 DE_TEST_ASSERT(exists);
366
367 WeakPtr<Object> weakPtr(ptr);
368 try
369 {
370 SharedPtr<Object> newRef(weakPtr);
371 DE_TEST_ASSERT(exists);
372 }
373 catch (const DeadReferenceException&)
374 {
375 DE_TEST_ASSERT(false);
376 }
377
378 ptr = SharedPtr<Object>();
379 DE_TEST_ASSERT(!exists);
380 try
381 {
382 SharedPtr<Object> newRef(weakPtr);
383 DE_TEST_ASSERT(false);
384 }
385 catch (const DeadReferenceException&)
386 {
387 }
388 }
389
390 // Basic SharedPtr threaded test.
391 {
392 bool exists = false;
393 {
394 SharedPtr<Object> ptr(new Object(exists));
395
396 SharedPtrTestThread threadA(ptr, exists);
397 SharedPtrTestThread threadB(ptr, exists);
398
399 threadA.start();
400 threadB.start();
401
402 threadA.join();
403 threadB.join();
404 DE_TEST_ASSERT(exists);
405 }
406 DE_TEST_ASSERT(!exists);
407 }
408
409 // Basic WeakPtr threaded test.
410 {
411 bool exists = false;
412 {
413 SharedPtr<Object> ptr(new Object(exists));
414 WeakPtrTestThread threadA(ptr, exists);
415 WeakPtrTestThread threadB(ptr, exists);
416
417 threadA.start();
418 threadB.start();
419
420 threadA.join();
421 threadB.join();
422 DE_TEST_ASSERT(exists);
423 }
424 DE_TEST_ASSERT(!exists);
425 }
426
427 // Basic custom deleter.
428 {
429 bool exists = false;
430 bool deleterCalled = false;
431 {
432 SharedPtr<Object> ptr(new Object(exists), CustomDeleter(&deleterCalled));
433 DE_TEST_ASSERT(exists);
434 DE_TEST_ASSERT(!deleterCalled);
435 DE_TEST_ASSERT(ptr.get() != DE_NULL);
436 }
437 DE_TEST_ASSERT(!exists);
438 DE_TEST_ASSERT(deleterCalled);
439 }
440 }
441
442 } // de
443