mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 12:44:46 +00:00
206 lines
6.4 KiB
C++
206 lines
6.4 KiB
C++
////-----------------------------------------------------------------------------
|
|
//// Copyright (c) 2014 GarageGames, LLC
|
|
////
|
|
//// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
//// of this software and associated documentation files (the "Software"), to
|
|
//// deal in the Software without restriction, including without limitation the
|
|
//// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
//// sell copies of the Software, and to permit persons to whom the Software is
|
|
//// furnished to do so, subject to the following conditions:
|
|
////
|
|
//// The above copyright notice and this permission notice shall be included in
|
|
//// all copies or substantial portions of the Software.
|
|
////
|
|
//// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
//// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
//// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
//// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
//// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
//// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
//// IN THE SOFTWARE.
|
|
////-----------------------------------------------------------------------------
|
|
//
|
|
//#ifdef TORQUE_TESTS_ENABLED
|
|
//#include "testing/unitTesting.h"
|
|
//#include "platform/threads/threadSafeRefCount.h"
|
|
//#include "platform/threads/thread.h"
|
|
//#include "core/util/tVector.h"
|
|
//#include "console/console.h"
|
|
//
|
|
//FIXTURE(ThreadSafeRefCount)
|
|
//{
|
|
//public:
|
|
// struct TestObjectDtor : public ThreadSafeRefCount<TestObjectDtor>
|
|
// {
|
|
// bool &flag;
|
|
// TestObjectDtor(bool &f) : flag(f)
|
|
// {
|
|
// flag = false;
|
|
// }
|
|
// ~TestObjectDtor()
|
|
// {
|
|
// flag = true;
|
|
// }
|
|
// };
|
|
// typedef ThreadSafeRef<TestObjectDtor> TestObjectDtorRef;
|
|
//
|
|
// enum
|
|
// {
|
|
// NUM_ADD_REFS_PER_THREAD = 10,
|
|
// NUM_EXTRA_REFS_PER_THREAD = 10,
|
|
// NUM_THREADS = 10
|
|
// };
|
|
//
|
|
// class TestObject : public ThreadSafeRefCount<TestObject> {};
|
|
// typedef ThreadSafeRef<TestObject> TestObjectRef;
|
|
//
|
|
// class TestThread : public Thread
|
|
// {
|
|
// public:
|
|
// TestObjectRef mRef;
|
|
// Vector<TestObjectRef> mExtraRefs;
|
|
//
|
|
// TestThread(TestObjectRef ref) : mRef(ref) {}
|
|
//
|
|
// void run(void* arg)
|
|
// {
|
|
// if (!arg)
|
|
// {
|
|
// // Create references.
|
|
// for (U32 i = 0; i < NUM_ADD_REFS_PER_THREAD; i++)
|
|
// mRef->addRef();
|
|
//
|
|
// mExtraRefs.setSize(NUM_EXTRA_REFS_PER_THREAD);
|
|
// for (U32 i = 0; i < NUM_EXTRA_REFS_PER_THREAD; i++)
|
|
// mExtraRefs[i] = mRef;
|
|
// }
|
|
// else
|
|
// {
|
|
// // Clear references.
|
|
// mExtraRefs.clear();
|
|
// for (U32 i = 0; i < NUM_ADD_REFS_PER_THREAD; i++)
|
|
// mRef->release();
|
|
// }
|
|
// }
|
|
// };
|
|
//
|
|
//};
|
|
//
|
|
//TEST_FIX(ThreadSafeRefCount, Serial)
|
|
//{
|
|
// bool deleted = false;
|
|
// TestObjectDtorRef ref1 = new TestObjectDtor(deleted);
|
|
// ASSERT_FALSE(deleted);
|
|
// EXPECT_FALSE(ref1->isShared());
|
|
// EXPECT_TRUE(ref1 != NULL);
|
|
//
|
|
// TestObjectDtorRef ref2 = ref1;
|
|
// EXPECT_TRUE(ref1->isShared());
|
|
// EXPECT_TRUE(ref2->isShared());
|
|
// EXPECT_EQ(ref1, ref2);
|
|
//
|
|
// ref1 = NULL;
|
|
// EXPECT_FALSE(ref2->isShared());
|
|
//
|
|
// ref2 = NULL;
|
|
// ASSERT_TRUE(deleted);
|
|
//}
|
|
//
|
|
//TEST_FIX(ThreadSafeRefCount, Concurrent)
|
|
//{
|
|
// TestObjectRef mRef = new TestObject;
|
|
// EXPECT_EQ(2, mRef->getRefCount()); // increments of 2
|
|
//
|
|
// Vector<TestThread*> threads;
|
|
// threads.setSize(NUM_THREADS);
|
|
//
|
|
// // Create threads.
|
|
// for (U32 i = 0; i < NUM_THREADS; i++)
|
|
// threads[i] = new TestThread(mRef);
|
|
//
|
|
// // Run phase 1: create references.
|
|
// for (U32 i = 0; i < NUM_THREADS; i++)
|
|
// threads[i]->start(NULL);
|
|
//
|
|
// // Wait for completion.
|
|
// for (U32 i = 0; i < NUM_THREADS; i++)
|
|
// threads[i]->join();
|
|
//
|
|
// EXPECT_EQ(2 + ((1 + NUM_ADD_REFS_PER_THREAD + NUM_EXTRA_REFS_PER_THREAD) * NUM_THREADS * 2),
|
|
// mRef->getRefCount());
|
|
//
|
|
// // Run phase 2: release references.
|
|
// for (U32 i = 0; i < NUM_THREADS; i++)
|
|
// threads[i]->start((void*) 1);
|
|
//
|
|
// // Wait for completion.
|
|
// for (U32 i = 0; i < NUM_THREADS; i++)
|
|
// {
|
|
// threads[i]->join();
|
|
// delete threads[i];
|
|
// }
|
|
//
|
|
// EXPECT_EQ(2, mRef->getRefCount()); // increments of two
|
|
//
|
|
// mRef = NULL;
|
|
//}
|
|
//
|
|
//TEST_FIX(ThreadSafeRefCount, Tagging)
|
|
//{
|
|
// TestObjectRef ref;
|
|
// EXPECT_FALSE(ref.isTagged());
|
|
// EXPECT_FALSE(bool(ref));
|
|
// EXPECT_FALSE(bool(ref.ptr()));
|
|
//
|
|
// EXPECT_TRUE(ref.trySetFromTo(ref, NULL));
|
|
// EXPECT_FALSE(ref.isTagged());
|
|
//
|
|
// EXPECT_TRUE(ref.trySetFromTo(ref, NULL, TestObjectRef::TAG_Set));
|
|
// EXPECT_TRUE(ref.isTagged());
|
|
// EXPECT_TRUE(ref.trySetFromTo(ref, NULL, TestObjectRef::TAG_Set));
|
|
// EXPECT_TRUE(ref.isTagged());
|
|
//
|
|
// EXPECT_TRUE(ref.trySetFromTo(ref, NULL, TestObjectRef::TAG_Unset));
|
|
// EXPECT_FALSE(ref.isTagged());
|
|
// EXPECT_TRUE(ref.trySetFromTo(ref, NULL, TestObjectRef::TAG_Unset));
|
|
// EXPECT_FALSE(ref.isTagged());
|
|
//
|
|
// EXPECT_TRUE(ref.trySetFromTo(ref, NULL, TestObjectRef::TAG_SetOrFail));
|
|
// EXPECT_TRUE(ref.isTagged());
|
|
// EXPECT_FALSE(ref.trySetFromTo(ref, NULL, TestObjectRef::TAG_SetOrFail));
|
|
// EXPECT_TRUE(ref.isTagged());
|
|
// EXPECT_FALSE(ref.trySetFromTo(ref, NULL, TestObjectRef::TAG_FailIfSet));
|
|
//
|
|
// EXPECT_TRUE(ref.trySetFromTo(ref, NULL, TestObjectRef::TAG_UnsetOrFail));
|
|
// EXPECT_FALSE(ref.isTagged());
|
|
// EXPECT_FALSE(ref.trySetFromTo(ref, NULL, TestObjectRef::TAG_UnsetOrFail));
|
|
// EXPECT_FALSE(ref.isTagged());
|
|
// EXPECT_FALSE(ref.trySetFromTo(ref, NULL, TestObjectRef::TAG_FailIfUnset));
|
|
//
|
|
// TestObjectRef objectA = new TestObject;
|
|
// TestObjectRef objectB = new TestObject;
|
|
//
|
|
// EXPECT_FALSE(objectA->isShared());
|
|
// EXPECT_FALSE(objectB->isShared());
|
|
//
|
|
// ref = objectA;
|
|
// EXPECT_FALSE(ref.isTagged());
|
|
// EXPECT_TRUE(ref == objectA);
|
|
// EXPECT_TRUE(ref == objectA.ptr());
|
|
// EXPECT_TRUE(objectA->isShared());
|
|
//
|
|
// EXPECT_TRUE(ref.trySetFromTo(objectA, objectB, TestObjectRef::TAG_Set));
|
|
// EXPECT_TRUE(ref.isTagged());
|
|
// EXPECT_EQ(ref, objectB);
|
|
// EXPECT_EQ(ref, objectB.ptr());
|
|
// EXPECT_TRUE(objectB->isShared());
|
|
// EXPECT_FALSE(objectA->isShared());
|
|
//
|
|
// EXPECT_TRUE(ref.trySetFromTo(ref, objectA));
|
|
// EXPECT_TRUE(ref.isTagged());
|
|
// EXPECT_EQ(ref, objectA);
|
|
// EXPECT_EQ(ref, objectA.ptr());
|
|
//}
|
|
//
|
|
//#endif
|