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: 44 Object (bool& exists) 45 : m_exists(exists) 46 { 47 m_exists = true; 48 } 49 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: 62 DerivedObject (bool& exists) 63 : Object(exists) 64 { 65 } 66 }; 67 68 class SharedPtrTestThread : public Thread 69 { 70 public: 71 SharedPtrTestThread (const SharedPtr<Object>& ptr, const bool& exists) 72 : m_ptr (ptr) 73 , m_exists (exists) 74 { 75 } 76 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: 107 WeakPtrTestThread (const SharedPtr<Object>& ptr, const bool& exists) 108 : m_ptr (ptr) 109 , m_exists (exists) 110 { 111 } 112 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 140 SharedPtr<Object> makeObject (bool& exists) 141 { 142 return SharedPtr<Object>(new Object(exists)); 143 } 144 145 struct CustomDeleter 146 { 147 CustomDeleter (bool* called) : m_called(called) {} 148 149 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 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, CustomDeleter> 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
