addThread
void addThread(std::string threadName, ThreadMethod method);
caller->addThread("A", &ExampleTest::TestFunc1);
caller->addThread("B", &ExampleTest::TestFunc2);
caller->addThread("C", &ExampleTest::TestFunc3);
caller->addThread("Thread1", &ExampleTest::TestFunc1);
caller->addThread("Thread2", &ExampleTest::TestFunc1);
caller->addThread("Thread3", &ExampleTest::TestFunc1);
caller->addThread("GoodThread1", &ExampleTest::TestFunc1);
caller->addThread("GoodThread2", &ExampleTest::TestFunc2);
caller->addThread("BadThread", &ExampleTest::FailureFunc);
testCaller->addThread("A", &AddMessageTest1::PerformTest);
testCaller->addThread("A", &AddMessageTest2::PerformTest);
threadedTest1->addThread("A", &ConcurrencyTest1::TestThread1);
threadedTest1->addThread("B", &ConcurrencyTest1::TestThread2);
threadedTest1->addThread("C", &ConcurrencyTest1::TestThread3);
threadedTest2->addThread("A", &ConcurrencyTest1::TestThread1);
threadedTest2->addThread("B", &ConcurrencyTest1::TestThread2);
threadedTest2->addThread("C", &ConcurrencyTest1::TestThread3);
threadedTest1->addThread("A", &ConcurrencyTest2::TestThread1);
threadedTest1->addThread("B", &ConcurrencyTest2::TestThread2);
threadedTest1->addThread("C", &ConcurrencyTest2::TestThread3);
threadedTest1->addThread("D", &ConcurrencyTest2::TestThread4);
threadedTest1->addThread("E", &ConcurrencyTest2::TestThread5);
threadedTest2->addThread("A", &ConcurrencyTest2::TestThread1);
threadedTest2->addThread("B", &ConcurrencyTest2::TestThread2);
threadedTest2->addThread("C", &ConcurrencyTest2::TestThread3);
threadedTest2->addThread("D", &ConcurrencyTest2::TestThread4);
threadedTest2->addThread("E", &ConcurrencyTest2::TestThread5);
testCaller->addThread("A", &FindMessageTest1::PerformTest);
caller4->addThread("A", &LockTargetTester::LockTargetTest4A);
caller4->addThread("B", &LockTargetTester::LockTargetTest4B);
caller5->addThread("A", &LockTargetTester::LockTargetTest5A);
caller5->addThread("B", &LockTargetTester::LockTargetTest5B);
caller4->addThread("A",
caller4->addThread("B",
caller5->addThread("A",
caller5->addThread("B",
caller6->addThread("A",
caller6->addThread("B",
caller7->addThread("A",
caller7->addThread("B",
testCaller->addThread(
testCaller->addThread("GetTest", &HttpIntegrationTest::GetTest);
testCaller->addThread("GetWithBufferTest", &HttpIntegrationTest::GetWithBufferTest);
testCaller->addThread("HeadTest", &HttpIntegrationTest::HeadTest);
testCaller->addThread("NoContentTest", &HttpIntegrationTest::NoContentTest);
testCaller->addThread("AutoRedirectTest", &HttpIntegrationTest::AutoRedirectTest);
testCaller->addThread("BasicAuthTest", &HttpIntegrationTest::BasicAuthTest);
testCaller->addThread("StopOnErrorTest", &HttpIntegrationTest::StopOnErrorTest);
testCaller->addThread("RequestCancelTest", &HttpIntegrationTest::RequestCancelTest);
testCaller->addThread("PostTest", &HttpIntegrationTest::PostTest);
testCaller->addThread(
testCaller->addThread("GetTest", &HttpIntegrationTest::GetTest);
testCaller->addThread("GetWithBufferTest", &HttpIntegrationTest::GetWithBufferTest);
testCaller->addThread("HeadTest", &HttpIntegrationTest::HeadTest);
testCaller->addThread("NoContentTest", &HttpIntegrationTest::NoContentTest);
testCaller->addThread("AutoRedirectTest", &HttpIntegrationTest::AutoRedirectTest);
testCaller->addThread("StopOnErrorTest", &HttpIntegrationTest::StopOnErrorTest);
testCaller->addThread("RequestCancelTest", &HttpIntegrationTest::RequestCancelTest);
testCaller->addThread("PostTest", &HttpIntegrationTest::PostTest);
testCaller.addThread("GetTest", &T::GetTest);
testCaller.addThread("HeadTest", &T::HeadTest);
testCaller.addThread("NoContentTest", &T::NoContentTest);
testCaller.addThread("UploadTest", &T::UploadTest);
testCaller.addThread("BasicAuthTest", &T::AuthBasicTest);
testCaller.addThread("DigestAuthTest", &T::AuthDigestTest);
testCaller.addThread("AutoRedirectTest", &T::AutoRedirectTest);
httpTestCaller->addThread("ProxyTest", &HttpTest::ProxyTest);
caller->addThread("WR", &MemoryRingIOTest::WriteTest);
caller->addThread("RD", &MemoryRingIOTest::ReadTest);
caller->addThread("WR", &MemoryRingIOTest::WriteTest);
caller->addThread("RD", &MemoryRingIOTest::ReadTest);
caller->addThread("WR", &MemoryRingIOTest::WriteTest);
caller->addThread("RD", &MemoryRingIOTest::ReadTest);
caller->addThread("WR #1", &MemoryRingIOTest::BusyWriterTest);
caller->addThread("WR #2", &MemoryRingIOTest::BusyWriterTest);
caller->addThread("WR #3", &MemoryRingIOTest::BusyWriterTest);
caller->addThread("RD", &MemoryRingIOTest::_DisableWriteOnFullBuffer);
caller->addThread("RD #1", &MemoryRingIOTest::BusyReaderTest);
caller->addThread("RD #2", &MemoryRingIOTest::BusyReaderTest);
caller->addThread("RD #3", &MemoryRingIOTest::BusyReaderTest);
caller->addThread("WR", &MemoryRingIOTest::_DisableWriteOnEmptyBuffer);
threadedTest->addThread("A", &AutolockLockerTest::Lock_Locker_MatchesThread);
threadedTest->addThread("B", &AutolockLockerTest::Construct_AutolockPtr_LocksLocker);
threadedTest->addThread("C", &AutolockLockerTest::Construct_AutolockRef_LocksLocker);
threadedTest->addThread("A", &AutolockLooperTest::Construct_AutolockPtr_LocksLooper);
threadedTest->addThread("A", &BlockCacheConcurrencyTest::TestThreadObj);
threadedTest->addThread("B", &BlockCacheConcurrencyTest::TestThreadObj);
threadedTest->addThread("C", &BlockCacheConcurrencyTest::TestThreadObj);
threadedTest->addThread("D", &BlockCacheConcurrencyTest::TestThreadMalloc);
threadedTest->addThread("E", &BlockCacheConcurrencyTest::TestThreadMalloc);
threadedTest->addThread("F", &BlockCacheConcurrencyTest::TestThreadMalloc);
simpleBenaphoreCaller->addThread("A", &LockerConcurrencyTest::SimpleLockingLoop);
simpleBenaphoreCaller->addThread("B", &LockerConcurrencyTest::SimpleLockingLoop);
simpleBenaphoreCaller->addThread("C", &LockerConcurrencyTest::SimpleLockingLoop);
simpleSemaphoreCaller->addThread("A", &LockerConcurrencyTest::SimpleLockingLoop);
simpleSemaphoreCaller->addThread("B", &LockerConcurrencyTest::SimpleLockingLoop);
simpleSemaphoreCaller->addThread("C", &LockerConcurrencyTest::SimpleLockingLoop);
timeoutBenaphoreCaller->addThread("Acquire", &LockerConcurrencyTest::AcquireThread);
timeoutBenaphoreCaller->addThread("Timeout1", &LockerConcurrencyTest::TimeoutThread);
timeoutBenaphoreCaller->addThread("Timeout2", &LockerConcurrencyTest::TimeoutThread);
timeoutSemaphoreCaller->addThread("Acquire", &LockerConcurrencyTest::AcquireThread);
timeoutSemaphoreCaller->addThread("Timeout1", &LockerConcurrencyTest::TimeoutThread);
timeoutSemaphoreCaller->addThread("Timeout2", &LockerConcurrencyTest::TimeoutThread);
simpleBenaphoreCaller->addThread("Waiter", &LockerDestructionTest::SimpleWaiterThread);
simpleBenaphoreCaller->addThread("Deleter", &LockerDestructionTest::SimpleDeleterThread);
simpleSemaphoreCaller->addThread("Waiter", &LockerDestructionTest::SimpleWaiterThread);
simpleSemaphoreCaller->addThread("Deleter", &LockerDestructionTest::SimpleDeleterThread);
timeoutBenaphoreCaller->addThread("Waiter", &LockerDestructionTest::TimeoutWaiterThread);
timeoutBenaphoreCaller->addThread("Deleter", &LockerDestructionTest::TimeoutDeleterThread);
timeoutSemaphoreCaller->addThread("Waiter", &LockerDestructionTest::TimeoutWaiterThread);
timeoutSemaphoreCaller->addThread("Deleter", &LockerDestructionTest::TimeoutDeleterThread);
caller1->addThread("A", &LockerLockCountTest::TestThread1);
caller1->addThread("B", &LockerLockCountTest::TestThread2);
caller1->addThread("C", &LockerLockCountTest::TestThread3);
caller2->addThread("A", &LockerLockCountTest::TestThread1);
caller2->addThread("B", &LockerLockCountTest::TestThread2);
caller2->addThread("C", &LockerLockCountTest::TestThread3);