You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@activemq.apache.org by ta...@apache.org on 2012/11/27 21:33:10 UTC
svn commit: r1414381 [2/2] - in
/activemq/activemq-cpp/trunk/activemq-cpp/src: main/decaf/lang/
main/decaf/util/ main/decaf/util/concurrent/ test-benchmarks/decaf/util/
test-integration/activemq/test/ test-integration/activemq/test/openwire/
test-integ...
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/FutureTaskTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/FutureTaskTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/FutureTaskTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/FutureTaskTest.cpp Tue Nov 27 20:32:53 2012
@@ -90,6 +90,11 @@ namespace {
FutureTaskTest* parent;
+ private:
+
+ MediumSleepCallable(const MediumSleepCallable&);
+ MediumSleepCallable operator= (const MediumSleepCallable&);
+
public:
MediumSleepCallable(FutureTaskTest* parent) : Callable<E>(), parent(parent) {
@@ -268,6 +273,11 @@ namespace {
FutureTaskTest* parent;
+ private:
+
+ MediumNoInterruptsSleepCallable(const MediumNoInterruptsSleepCallable&);
+ MediumNoInterruptsSleepCallable operator= (const MediumNoInterruptsSleepCallable&);
+
public:
MediumNoInterruptsSleepCallable(FutureTaskTest* parent) : Callable<E>(), parent(parent) {
@@ -315,6 +325,11 @@ namespace {
FutureTaskTest* parent;
FutureTask<std::string>* task;
+ private:
+
+ MediumNoInterruptsSleepRunnable(const MediumNoInterruptsSleepRunnable&);
+ MediumNoInterruptsSleepRunnable operator= (const MediumNoInterruptsSleepRunnable&);
+
public:
MediumNoInterruptsSleepRunnable(FutureTaskTest* parent, FutureTask<std::string>* task) :
@@ -364,6 +379,11 @@ namespace {
FutureTaskTest* parent;
FutureTask<std::string>* task;
+ private:
+
+ GetDelayedFutureTaskRunnable(const GetDelayedFutureTaskRunnable&);
+ GetDelayedFutureTaskRunnable operator= (const GetDelayedFutureTaskRunnable&);
+
public:
GetDelayedFutureTaskRunnable(FutureTaskTest* parent, FutureTask<std::string>* task) :
@@ -413,6 +433,11 @@ namespace {
FutureTaskTest* parent;
+ private:
+
+ ShortSleepCallable(const ShortSleepCallable&);
+ ShortSleepCallable operator= (const ShortSleepCallable&);
+
public:
ShortSleepCallable(FutureTaskTest* parent) : Callable<E>(), parent(parent) {
@@ -438,6 +463,11 @@ namespace {
FutureTaskTest* parent;
FutureTask<std::string>* task;
+ private:
+
+ InterruptedGetDelayedFutureTaskRunnable(const InterruptedGetDelayedFutureTaskRunnable&);
+ InterruptedGetDelayedFutureTaskRunnable operator= (const InterruptedGetDelayedFutureTaskRunnable&);
+
public:
InterruptedGetDelayedFutureTaskRunnable(FutureTaskTest* parent, FutureTask<std::string>* task) :
@@ -488,6 +518,11 @@ namespace {
FutureTaskTest* parent;
FutureTask<std::string>* task;
+ private:
+
+ CancelledGetFutureTaskRunnable(const CancelledGetFutureTaskRunnable&);
+ CancelledGetFutureTaskRunnable operator= (const CancelledGetFutureTaskRunnable&);
+
public:
CancelledGetFutureTaskRunnable(FutureTaskTest* parent, FutureTask<std::string>* task) :
@@ -538,6 +573,11 @@ namespace {
FutureTaskTest* parent;
+ private:
+
+ ErrorThrowingCallable(const ErrorThrowingCallable&);
+ ErrorThrowingCallable operator= (const ErrorThrowingCallable&);
+
public:
ErrorThrowingCallable(FutureTaskTest* parent) : Callable<E>(), parent(parent) {
@@ -593,6 +633,11 @@ namespace {
FutureTaskTest* parent;
FutureTask<std::string>* task;
+ private:
+
+ InterruptableFutureTaskGetRunnable(const InterruptableFutureTaskGetRunnable&);
+ InterruptableFutureTaskGetRunnable operator= (const InterruptableFutureTaskGetRunnable&);
+
public:
InterruptableFutureTaskGetRunnable(FutureTaskTest* parent, FutureTask<std::string>* task) :
@@ -639,6 +684,11 @@ namespace {
FutureTaskTest* parent;
FutureTask<std::string>* task;
+ private:
+
+ InterruptableFutureTaskLongTimeoutGetRunnable(const InterruptableFutureTaskLongTimeoutGetRunnable&);
+ InterruptableFutureTaskLongTimeoutGetRunnable operator= (const InterruptableFutureTaskLongTimeoutGetRunnable&);
+
public:
InterruptableFutureTaskLongTimeoutGetRunnable(FutureTaskTest* parent, FutureTask<std::string>* task) :
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/LinkedBlockingQueueTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/LinkedBlockingQueueTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/LinkedBlockingQueueTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/LinkedBlockingQueueTest.cpp Tue Nov 27 20:32:53 2012
@@ -603,6 +603,11 @@ namespace {
LinkedBlockingQueue<int>* theQ;
int putValue;
+ private:
+
+ PutThread(const PutThread&);
+ PutThread operator= (const PutThread&);
+
public:
PutThread(LinkedBlockingQueue<int>* q, int putValue) : theQ(q), putValue(putValue) {}
@@ -720,6 +725,11 @@ namespace {
LinkedBlockingQueue<int>* theQ;
int count;
+ private:
+
+ PuttingThread(const PuttingThread&);
+ PuttingThread operator= (const PuttingThread&);
+
public:
PuttingThread(LinkedBlockingQueue<int>* q, int count) : theQ(q), count(count) {}
@@ -749,6 +759,11 @@ namespace {
int count;
LinkedList<int>* list;
+ private:
+
+ TakingThread(const TakingThread&);
+ TakingThread operator= (const TakingThread&);
+
public:
TakingThread(LinkedBlockingQueue<int>* q, LinkedList<int>* list, int count) :
@@ -945,6 +960,11 @@ namespace {
LinkedBlockingQueueTest* test;
+ private:
+
+ TestBlockingPutRunnable(const TestBlockingPutRunnable&);
+ TestBlockingPutRunnable operator= (const TestBlockingPutRunnable&);
+
public:
TestBlockingPutRunnable(LinkedBlockingQueueTest* test) : Runnable(), test(test) {
@@ -994,6 +1014,11 @@ namespace {
LinkedBlockingQueue<int>* queue;
LinkedBlockingQueueTest* test;
+ private:
+
+ TestTimedOfferRunnable(const TestTimedOfferRunnable&);
+ TestTimedOfferRunnable operator= (const TestTimedOfferRunnable&);
+
public:
TestTimedOfferRunnable(LinkedBlockingQueue<int>* queue, LinkedBlockingQueueTest* test) :
@@ -1042,6 +1067,11 @@ namespace {
LinkedBlockingQueue<int>* queue;
LinkedBlockingQueueTest* test;
+ private:
+
+ TestTakeFromEmptyRunnable(const TestTakeFromEmptyRunnable&);
+ TestTakeFromEmptyRunnable operator= (const TestTakeFromEmptyRunnable&);
+
public:
TestTakeFromEmptyRunnable(LinkedBlockingQueue<int>* queue, LinkedBlockingQueueTest* test) :
@@ -1085,6 +1115,11 @@ namespace {
LinkedBlockingQueueTest* test;
+ private:
+
+ TestBlockingTakeRunnable(const TestBlockingTakeRunnable&);
+ TestBlockingTakeRunnable operator= (const TestBlockingTakeRunnable&);
+
public:
TestBlockingTakeRunnable(LinkedBlockingQueueTest* test) :
@@ -1133,6 +1168,11 @@ namespace {
LinkedBlockingQueueTest* test;
+ private:
+
+ TestInterruptedTimedPollRunnable(const TestInterruptedTimedPollRunnable&);
+ TestInterruptedTimedPollRunnable operator= (const TestInterruptedTimedPollRunnable&);
+
public:
TestInterruptedTimedPollRunnable(LinkedBlockingQueueTest* test) :
@@ -1184,6 +1224,11 @@ namespace {
LinkedBlockingQueue<int>* queue;
LinkedBlockingQueueTest* test;
+ private:
+
+ TestTimedPollWithOfferRunnable(const TestTimedPollWithOfferRunnable&);
+ TestTimedPollWithOfferRunnable operator= (const TestTimedPollWithOfferRunnable&);
+
public:
TestTimedPollWithOfferRunnable(LinkedBlockingQueue<int>* queue, LinkedBlockingQueueTest* test) :
@@ -1232,6 +1277,11 @@ namespace {
LinkedBlockingQueue<int>* queue;
LinkedBlockingQueueTest* test;
+ private:
+
+ TestOfferInExecutor1(const TestOfferInExecutor1&);
+ TestOfferInExecutor1 operator= (const TestOfferInExecutor1&);
+
public:
TestOfferInExecutor1(LinkedBlockingQueue<int>* queue, LinkedBlockingQueueTest* test) :
@@ -1257,6 +1307,11 @@ namespace {
LinkedBlockingQueue<int>* queue;
LinkedBlockingQueueTest* test;
+ private:
+
+ TestOfferInExecutor2(const TestOfferInExecutor2&);
+ TestOfferInExecutor2 operator= (const TestOfferInExecutor2&);
+
public:
TestOfferInExecutor2(LinkedBlockingQueue<int>* queue, LinkedBlockingQueueTest* test) :
@@ -1301,6 +1356,11 @@ namespace {
LinkedBlockingQueue<int>* queue;
LinkedBlockingQueueTest* test;
+ private:
+
+ TestPollInExecutor1(const TestPollInExecutor1&);
+ TestPollInExecutor1 operator= (const TestPollInExecutor1&);
+
public:
TestPollInExecutor1(LinkedBlockingQueue<int>* queue, LinkedBlockingQueueTest* test) :
@@ -1327,6 +1387,11 @@ namespace {
LinkedBlockingQueue<int>* queue;
LinkedBlockingQueueTest* test;
+ private:
+
+ TestPollInExecutor2(const TestPollInExecutor2&);
+ TestPollInExecutor2 operator= (const TestPollInExecutor2&);
+
public:
TestPollInExecutor2(LinkedBlockingQueue<int>* queue, LinkedBlockingQueueTest* test) :
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/MutexTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/MutexTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/MutexTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/MutexTest.cpp Tue Nov 27 20:32:53 2012
@@ -53,7 +53,7 @@ class MyThread : public lang::Thread, pu
public:
volatile int value;
- MyThread(){ value = 0;}
+ MyThread() : value(0) {}
virtual ~MyThread(){}
virtual void run(){
@@ -90,7 +90,7 @@ public:
volatile int value;
volatile bool started;
- MyWaitingThread(){ value = 0; started = false; }
+ MyWaitingThread() : value(0), started(false) {}
virtual ~MyWaitingThread(){}
virtual void run(){
@@ -147,7 +147,7 @@ public:
volatile int value;
volatile bool started;
- MyTimedWaitingThread(){ value = 0; started = false; }
+ MyTimedWaitingThread() : value(0), started(false) {}
virtual ~MyTimedWaitingThread(){}
virtual void run(){
@@ -216,14 +216,16 @@ public:
Mutex* started;
Mutex* completed;
+private:
+
+ MyNotifiedThread(const MyNotifiedThread&);
+ MyNotifiedThread& operator= (const MyNotifiedThread&);
+
public:
int value;
- MyNotifiedThread(Mutex* mutex, Mutex* started, Mutex* completed ){
- this->mutex = mutex;
- this->started = started;
- this->completed = completed;
- this->done = false;
+ MyNotifiedThread(Mutex* mutex, Mutex* started, Mutex* completed ) :
+ done(false), mutex(mutex), started(started), completed(completed), value() {
}
virtual ~MyNotifiedThread(){}
@@ -454,14 +456,16 @@ public:
Mutex* mutex;
int index;
+private:
+
+ MyRecursiveLockThread(const MyRecursiveLockThread&);
+ MyRecursiveLockThread& operator= (const MyRecursiveLockThread&);
+
public:
volatile int value;
- MyRecursiveLockThread(Mutex* mutex, int index){
- this->mutex = mutex;
- this->done = false;
- this->index = index;
- }
+ MyRecursiveLockThread(Mutex* mutex, int index) : done(false), mutex(mutex), index(index), value() {}
+
virtual ~MyRecursiveLockThread(){}
virtual void lock() {
@@ -583,13 +587,16 @@ public:
Mutex* mutex1;
Mutex* mutex2;
+private:
+
+ MyDoubleLockThread(const MyDoubleLockThread&);
+ MyDoubleLockThread& operator= (const MyDoubleLockThread&);
+
public:
volatile int value;
- MyDoubleLockThread(Mutex* mutex1, Mutex* mutex2) {
- this->mutex1 = mutex1;
- this->mutex2 = mutex2;
- done = false;
+ MyDoubleLockThread(Mutex* mutex1, Mutex* mutex2) :
+ done(false), mutex1(mutex1), mutex2(mutex2), value(0) {
}
virtual ~MyDoubleLockThread(){}
@@ -653,13 +660,14 @@ public:
lang::Thread* thread;
util::Random rand;
+private:
+
+ MyStoppableThread(const MyStoppableThread&);
+ MyStoppableThread& operator= (const MyStoppableThread&);
+
public:
- MyStoppableThread() {
- this->started = false;
- this->closed = false;
- this->thread = NULL;
- }
+ MyStoppableThread() : started(false), closed(false), mutex(), thread(), rand() {}
virtual ~MyStoppableThread(){ close(); }
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/SemaphoreTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/SemaphoreTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/SemaphoreTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/SemaphoreTest.cpp Tue Nov 27 20:32:53 2012
@@ -58,6 +58,11 @@ namespace {
Semaphore* lock;
SemaphoreTest* parent;
+ private:
+
+ InterruptibleLockRunnable(const InterruptibleLockRunnable&);
+ InterruptibleLockRunnable operator= (const InterruptibleLockRunnable&);
+
public:
InterruptibleLockRunnable(Semaphore* l, SemaphoreTest* parent) :
@@ -78,6 +83,11 @@ namespace {
Semaphore* lock;
SemaphoreTest* parent;
+ private:
+
+ InterruptedLockRunnable(const InterruptedLockRunnable&);
+ InterruptedLockRunnable operator= (const InterruptedLockRunnable&);
+
public:
InterruptedLockRunnable(Semaphore* l, SemaphoreTest* parent) :
@@ -211,6 +221,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestAcquireReleaseInDifferentThreadsRunnable(const TestAcquireReleaseInDifferentThreadsRunnable&);
+ TestAcquireReleaseInDifferentThreadsRunnable operator= (const TestAcquireReleaseInDifferentThreadsRunnable&);
+
public:
TestAcquireReleaseInDifferentThreadsRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -260,6 +275,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestUninterruptibleAcquireReleaseInDifferentThreadsRunnable(const TestUninterruptibleAcquireReleaseInDifferentThreadsRunnable&);
+ TestUninterruptibleAcquireReleaseInDifferentThreadsRunnable operator= (const TestUninterruptibleAcquireReleaseInDifferentThreadsRunnable&);
+
public:
TestUninterruptibleAcquireReleaseInDifferentThreadsRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -305,6 +325,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestTimedAcquireReleaseInDifferentThreadsRunnable(const TestTimedAcquireReleaseInDifferentThreadsRunnable&);
+ TestTimedAcquireReleaseInDifferentThreadsRunnable operator= (const TestTimedAcquireReleaseInDifferentThreadsRunnable&);
+
public:
TestTimedAcquireReleaseInDifferentThreadsRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -353,6 +378,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestAcquireInterruptedExceptionRunnable(const TestAcquireInterruptedExceptionRunnable&);
+ TestAcquireInterruptedExceptionRunnable operator= (const TestAcquireInterruptedExceptionRunnable&);
+
public:
TestAcquireInterruptedExceptionRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -395,6 +425,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestTryAcquireInterruptedExceptionRunnable(const TestTryAcquireInterruptedExceptionRunnable&);
+ TestTryAcquireInterruptedExceptionRunnable operator= (const TestTryAcquireInterruptedExceptionRunnable&);
+
public:
TestTryAcquireInterruptedExceptionRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -685,6 +720,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestAcquireReleaseInDifferentThreadsFairRunnable(const TestAcquireReleaseInDifferentThreadsFairRunnable&);
+ TestAcquireReleaseInDifferentThreadsFairRunnable operator= (const TestAcquireReleaseInDifferentThreadsFairRunnable&);
+
public:
TestAcquireReleaseInDifferentThreadsFairRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -735,6 +775,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestAcquireReleaseNInDifferentThreadsFairRunnable(const TestAcquireReleaseNInDifferentThreadsFairRunnable&);
+ TestAcquireReleaseNInDifferentThreadsFairRunnable operator= (const TestAcquireReleaseNInDifferentThreadsFairRunnable&);
+
public:
TestAcquireReleaseNInDifferentThreadsFairRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -780,6 +825,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestAcquireReleaseNInDifferentThreadsFair2Runnable(const TestAcquireReleaseNInDifferentThreadsFair2Runnable&);
+ TestAcquireReleaseNInDifferentThreadsFair2Runnable operator= (const TestAcquireReleaseNInDifferentThreadsFair2Runnable&);
+
public:
TestAcquireReleaseNInDifferentThreadsFair2Runnable(Semaphore* sem, SemaphoreTest* parent)
@@ -826,6 +876,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestTimedAcquireReleaseInDifferentThreadsFairRunnable(const TestTimedAcquireReleaseInDifferentThreadsFairRunnable&);
+ TestTimedAcquireReleaseInDifferentThreadsFairRunnable operator= (const TestTimedAcquireReleaseInDifferentThreadsFairRunnable&);
+
public:
TestTimedAcquireReleaseInDifferentThreadsFairRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -874,6 +929,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestTimedAcquireReleaseNInDifferentThreadsFairRunnable(const TestTimedAcquireReleaseNInDifferentThreadsFairRunnable&);
+ TestTimedAcquireReleaseNInDifferentThreadsFairRunnable operator= (const TestTimedAcquireReleaseNInDifferentThreadsFairRunnable&);
+
public:
TestTimedAcquireReleaseNInDifferentThreadsFairRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -920,6 +980,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestAcquireInterruptedExceptionFairRunnable(const TestAcquireInterruptedExceptionFairRunnable&);
+ TestAcquireInterruptedExceptionFairRunnable operator= (const TestAcquireInterruptedExceptionFairRunnable&);
+
public:
TestAcquireInterruptedExceptionFairRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -960,6 +1025,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestAcquireNInterruptedExceptionFairRunnable(const TestAcquireNInterruptedExceptionFairRunnable&);
+ TestAcquireNInterruptedExceptionFairRunnable operator= (const TestAcquireNInterruptedExceptionFairRunnable&);
+
public:
TestAcquireNInterruptedExceptionFairRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -1000,6 +1070,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestTryAcquireInterruptedExceptionFairRunnable(const TestTryAcquireInterruptedExceptionFairRunnable&);
+ TestTryAcquireInterruptedExceptionFairRunnable operator= (const TestTryAcquireInterruptedExceptionFairRunnable&);
+
public:
TestTryAcquireInterruptedExceptionFairRunnable(Semaphore* sem, SemaphoreTest* parent)
@@ -1041,6 +1116,11 @@ namespace {
Semaphore* sem;
SemaphoreTest* parent;
+ private:
+
+ TestTryAcquireNInterruptedExceptionFairRunnable(const TestTryAcquireNInterruptedExceptionFairRunnable&);
+ TestTryAcquireNInterruptedExceptionFairRunnable operator= (const TestTryAcquireNInterruptedExceptionFairRunnable&);
+
public:
TestTryAcquireNInterruptedExceptionFairRunnable(Semaphore* sem, SemaphoreTest* parent)
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ThreadPoolExecutorTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ThreadPoolExecutorTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ThreadPoolExecutorTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ThreadPoolExecutorTest.cpp Tue Nov 27 20:32:53 2012
@@ -34,6 +34,11 @@ using namespace decaf::util::concurrent;
namespace {
class MyTask : public lang::Runnable {
+ private:
+
+ MyTask(const MyTask&);
+ MyTask operator= (const MyTask&);
+
public:
CountDownLatch* latch;
@@ -52,11 +57,16 @@ namespace {
};
class MyExceptionTask : public lang::Runnable {
+ private:
+
+ MyExceptionTask(const MyExceptionTask&);
+ MyExceptionTask operator= (const MyExceptionTask&);
+
public:
int value;
- MyExceptionTask() : Runnable() {
+ MyExceptionTask() : Runnable(), value() {
}
virtual ~MyExceptionTask() {}
@@ -67,14 +77,17 @@ namespace {
};
class MyWaitingTask : public lang::Runnable {
+ private:
+
+ MyWaitingTask(const MyWaitingTask&);
+ MyWaitingTask operator= (const MyWaitingTask&);
+
public:
Mutex* mutex;
CountDownLatch* startedLatch;
- MyWaitingTask( Mutex* mutex, CountDownLatch* startedLatch ) {
- this->mutex = mutex;
- this->startedLatch = startedLatch;
+ MyWaitingTask( Mutex* mutex, CountDownLatch* startedLatch ) : mutex(mutex), startedLatch(startedLatch) {
}
virtual ~MyWaitingTask() {};
@@ -96,6 +109,11 @@ namespace {
class DefaultThreadFactoryRunnable : public Runnable {
private:
+ DefaultThreadFactoryRunnable(const DefaultThreadFactoryRunnable&);
+ DefaultThreadFactoryRunnable operator= (const DefaultThreadFactoryRunnable&);
+
+ private:
+
CountDownLatch* shutdown;
public:
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ThreadPoolExecutorTest.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ThreadPoolExecutorTest.h?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ThreadPoolExecutorTest.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/ThreadPoolExecutorTest.h Tue Nov 27 20:32:53 2012
@@ -114,7 +114,7 @@ namespace concurrent{
public:
- ThreadPoolExecutorTest() {}
+ ThreadPoolExecutorTest() : myMutex() {}
virtual ~ThreadPoolExecutorTest() {}
void testConstructor();
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicBooleanTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicBooleanTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicBooleanTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicBooleanTest.cpp Tue Nov 27 20:32:53 2012
@@ -72,6 +72,11 @@ private:
AtomicBoolean* aip;
+private:
+
+ MyRunnable(const MyRunnable&);
+ MyRunnable operator= (const MyRunnable&);
+
public:
MyRunnable( AtomicBoolean* ai ) : aip( ai ) {}
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicIntegerTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicIntegerTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicIntegerTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicIntegerTest.cpp Tue Nov 27 20:32:53 2012
@@ -77,6 +77,11 @@ private:
AtomicInteger* aip;
+private:
+
+ MyIntRunnable(const MyIntRunnable&);
+ MyIntRunnable operator= (const MyIntRunnable&);
+
public:
MyIntRunnable( AtomicInteger* ai ) :
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicReferenceTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicReferenceTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicReferenceTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/atomic/AtomicReferenceTest.cpp Tue Nov 27 20:32:53 2012
@@ -76,6 +76,11 @@ private:
AtomicReference<int>* aip;
+private:
+
+ MyRefedRunnable(const MyRefedRunnable&);
+ MyRefedRunnable operator= (const MyRefedRunnable&);
+
public:
int value1;
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/AbstractQueuedSynchronizerTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/AbstractQueuedSynchronizerTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/AbstractQueuedSynchronizerTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/AbstractQueuedSynchronizerTest.cpp Tue Nov 27 20:32:53 2012
@@ -90,6 +90,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
TestMutex* mutex;
+ private:
+
+ InterruptibleSyncRunnable(const InterruptibleSyncRunnable&);
+ InterruptibleSyncRunnable operator= (const InterruptibleSyncRunnable&);
+
public:
InterruptibleSyncRunnable(AbstractQueuedSynchronizerTest* parent,
@@ -114,6 +119,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
TestMutex* mutex;
+ private:
+
+ InterruptedSyncRunnable(const InterruptedSyncRunnable&);
+ InterruptedSyncRunnable operator= (const InterruptedSyncRunnable&);
+
public:
InterruptedSyncRunnable(AbstractQueuedSynchronizerTest* parent,
@@ -426,6 +436,11 @@ namespace {
TestMutex* mutex;
AbstractQueuedSynchronizerTest* parent;
+ private:
+
+ TestInterruptedException2Runnable(const TestInterruptedException2Runnable&);
+ TestInterruptedException2Runnable operator= (const TestInterruptedException2Runnable&);
+
public:
TestInterruptedException2Runnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex) :
@@ -467,6 +482,11 @@ namespace {
TestMutex* mutex;
AbstractQueuedSynchronizerTest* parent;
+ private:
+
+ TestTryAcquireWhenSyncedRunnable(const TestTryAcquireWhenSyncedRunnable&);
+ TestTryAcquireWhenSyncedRunnable operator= (const TestTryAcquireWhenSyncedRunnable&);
+
public:
TestTryAcquireWhenSyncedRunnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex) :
@@ -504,6 +524,11 @@ namespace {
TestMutex* mutex;
AbstractQueuedSynchronizerTest* parent;
+ private:
+
+ TestAcquireNanosTimeoutRunnable(const TestAcquireNanosTimeoutRunnable&);
+ TestAcquireNanosTimeoutRunnable operator= (const TestAcquireNanosTimeoutRunnable&);
+
public:
TestAcquireNanosTimeoutRunnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex) :
@@ -545,6 +570,11 @@ namespace {
TestMutex* mutex;
AbstractQueuedSynchronizerTest* parent;
+ private:
+
+ TestGetStateRunnable(const TestGetStateRunnable&);
+ TestGetStateRunnable operator= (const TestGetStateRunnable&);
+
public:
TestGetStateRunnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex) :
@@ -656,7 +686,7 @@ void AbstractQueuedSynchronizerTest::tes
try {
c->signal();
shouldThrow();
- } catch(IllegalMonitorStateException success) {
+ } catch(IllegalMonitorStateException& success) {
} catch(Exception& ex) {
unexpectedException();
}
@@ -717,6 +747,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
Condition* cond;
+ private:
+
+ TestAwaitRunnable(const TestAwaitRunnable&);
+ TestAwaitRunnable operator= (const TestAwaitRunnable&);
+
public:
TestAwaitRunnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, Condition* cond) :
@@ -816,7 +851,7 @@ void AbstractQueuedSynchronizerTest::tes
try {
mutex.hasWaiters(c);
shouldThrow();
- } catch(IllegalMonitorStateException success) {
+ } catch(IllegalMonitorStateException& success) {
} catch(Exception& ex) {
unexpectedException();
}
@@ -831,7 +866,7 @@ void AbstractQueuedSynchronizerTest::tes
try {
mutex2.getWaitQueueLength(c);
shouldThrow();
- } catch(IllegalArgumentException success) {
+ } catch(IllegalArgumentException& success) {
} catch(Exception& ex) {
unexpectedException();
}
@@ -845,7 +880,7 @@ void AbstractQueuedSynchronizerTest::tes
try {
mutex.getWaitQueueLength(c);
shouldThrow();
- } catch(IllegalMonitorStateException success) {
+ } catch(IllegalMonitorStateException& success) {
} catch(Exception& ex) {
unexpectedException();
}
@@ -860,7 +895,7 @@ void AbstractQueuedSynchronizerTest::tes
try {
mutex2.getWaitingThreads(c);
shouldThrow();
- } catch(IllegalArgumentException success) {
+ } catch(IllegalArgumentException& success) {
} catch(Exception& ex) {
unexpectedException();
}
@@ -874,7 +909,7 @@ void AbstractQueuedSynchronizerTest::tes
try {
mutex.getWaitingThreads(c);
shouldThrow();
- } catch(IllegalMonitorStateException success) {
+ } catch(IllegalMonitorStateException& success) {
} catch(Exception& ex) {
unexpectedException();
}
@@ -891,6 +926,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
AbstractQueuedSynchronizer::ConditionObject* cond;
+ private:
+
+ TestHasWaitersRunnable(const TestHasWaitersRunnable&);
+ TestHasWaitersRunnable operator= (const TestHasWaitersRunnable&);
+
public:
TestHasWaitersRunnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, AbstractQueuedSynchronizer::ConditionObject* cond) :
@@ -950,6 +990,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
AbstractQueuedSynchronizer::ConditionObject* cond;
+ private:
+
+ testGetWaitQueueLengthRunnable1(const testGetWaitQueueLengthRunnable1&);
+ testGetWaitQueueLengthRunnable1 operator= (const testGetWaitQueueLengthRunnable1&);
+
public:
testGetWaitQueueLengthRunnable1(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, AbstractQueuedSynchronizer::ConditionObject* cond) :
@@ -977,6 +1022,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
AbstractQueuedSynchronizer::ConditionObject* cond;
+ private:
+
+ testGetWaitQueueLengthRunnable2(const testGetWaitQueueLengthRunnable2&);
+ testGetWaitQueueLengthRunnable2 operator= (const testGetWaitQueueLengthRunnable2&);
+
public:
testGetWaitQueueLengthRunnable2(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, AbstractQueuedSynchronizer::ConditionObject* cond) :
@@ -1043,6 +1093,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
AbstractQueuedSynchronizer::ConditionObject* cond;
+ private:
+
+ TestGetWaitingThreadsRunnable1(const TestGetWaitingThreadsRunnable1&);
+ TestGetWaitingThreadsRunnable1 operator= (const TestGetWaitingThreadsRunnable1&);
+
public:
TestGetWaitingThreadsRunnable1(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, AbstractQueuedSynchronizer::ConditionObject* cond) :
@@ -1070,6 +1125,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
AbstractQueuedSynchronizer::ConditionObject* cond;
+ private:
+
+ TestGetWaitingThreadsRunnable2(const TestGetWaitingThreadsRunnable2&);
+ TestGetWaitingThreadsRunnable2 operator= (const TestGetWaitingThreadsRunnable2&);
+
public:
TestGetWaitingThreadsRunnable2(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, AbstractQueuedSynchronizer::ConditionObject* cond) :
@@ -1140,6 +1200,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
AbstractQueuedSynchronizer::ConditionObject* cond;
+ private:
+
+ TestAwaitUninterruptiblyRunnable(const TestAwaitUninterruptiblyRunnable&);
+ TestAwaitUninterruptiblyRunnable operator= (const TestAwaitUninterruptiblyRunnable&);
+
public:
TestAwaitUninterruptiblyRunnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, AbstractQueuedSynchronizer::ConditionObject* cond) :
@@ -1187,6 +1252,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
AbstractQueuedSynchronizer::ConditionObject* cond;
+ private:
+
+ TestAwaitInterruptRunnable(const TestAwaitInterruptRunnable&);
+ TestAwaitInterruptRunnable operator= (const TestAwaitInterruptRunnable&);
+
public:
TestAwaitInterruptRunnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, AbstractQueuedSynchronizer::ConditionObject* cond) :
@@ -1235,6 +1305,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
AbstractQueuedSynchronizer::ConditionObject* cond;
+ private:
+
+ TestAwaitNanosInterruptRunnable(const TestAwaitNanosInterruptRunnable&);
+ TestAwaitNanosInterruptRunnable operator= (const TestAwaitNanosInterruptRunnable&);
+
public:
TestAwaitNanosInterruptRunnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, AbstractQueuedSynchronizer::ConditionObject* cond) :
@@ -1283,6 +1358,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
AbstractQueuedSynchronizer::ConditionObject* cond;
+ private:
+
+ TestAwaitUntilInterruptRunnable(const TestAwaitUntilInterruptRunnable&);
+ TestAwaitUntilInterruptRunnable operator= (const TestAwaitUntilInterruptRunnable&);
+
public:
TestAwaitUntilInterruptRunnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, AbstractQueuedSynchronizer::ConditionObject* cond) :
@@ -1332,6 +1412,11 @@ namespace {
AbstractQueuedSynchronizerTest* parent;
AbstractQueuedSynchronizer::ConditionObject* cond;
+ private:
+
+ TestSignalAllRunnable(const TestSignalAllRunnable&);
+ TestSignalAllRunnable operator= (const TestSignalAllRunnable&);
+
public:
TestSignalAllRunnable(AbstractQueuedSynchronizerTest* parent, TestMutex* mutex, AbstractQueuedSynchronizer::ConditionObject* cond) :
@@ -1415,6 +1500,11 @@ namespace {
BooleanLatch* latch;
AbstractQueuedSynchronizerTest* parent;
+ private:
+
+ TestAcquireSharedInterruptiblyRunnable(const TestAcquireSharedInterruptiblyRunnable&);
+ TestAcquireSharedInterruptiblyRunnable operator= (const TestAcquireSharedInterruptiblyRunnable&);
+
public:
TestAcquireSharedInterruptiblyRunnable(AbstractQueuedSynchronizerTest* parent, BooleanLatch* latch) :
@@ -1460,6 +1550,11 @@ namespace {
BooleanLatch* latch;
AbstractQueuedSynchronizerTest* parent;
+ private:
+
+ TestAsquireSharedTimedRunnable(const TestAsquireSharedTimedRunnable&);
+ TestAsquireSharedTimedRunnable operator= (const TestAsquireSharedTimedRunnable&);
+
public:
TestAsquireSharedTimedRunnable(AbstractQueuedSynchronizerTest* parent, BooleanLatch* latch) :
@@ -1505,6 +1600,11 @@ namespace {
BooleanLatch* latch;
AbstractQueuedSynchronizerTest* parent;
+ private:
+
+ TestAcquireSharedInterruptiblyInterruptedExceptionRunnable(const TestAcquireSharedInterruptiblyInterruptedExceptionRunnable&);
+ TestAcquireSharedInterruptiblyInterruptedExceptionRunnable operator= (const TestAcquireSharedInterruptiblyInterruptedExceptionRunnable&);
+
public:
TestAcquireSharedInterruptiblyInterruptedExceptionRunnable(AbstractQueuedSynchronizerTest* parent, BooleanLatch* latch) :
@@ -1547,6 +1647,11 @@ namespace {
BooleanLatch* latch;
AbstractQueuedSynchronizerTest* parent;
+ private:
+
+ TestAcquireSharedNanosInterruptedExceptionRunnable(const TestAcquireSharedNanosInterruptedExceptionRunnable&);
+ TestAcquireSharedNanosInterruptedExceptionRunnable operator= (const TestAcquireSharedNanosInterruptedExceptionRunnable&);
+
public:
TestAcquireSharedNanosInterruptedExceptionRunnable(AbstractQueuedSynchronizerTest* parent, BooleanLatch* latch) :
@@ -1590,6 +1695,11 @@ namespace {
BooleanLatch* latch;
AbstractQueuedSynchronizerTest* parent;
+ private:
+
+ TestAcquireSharedNanosTimeoutRunnable(const TestAcquireSharedNanosTimeoutRunnable&);
+ TestAcquireSharedNanosTimeoutRunnable operator= (const TestAcquireSharedNanosTimeoutRunnable&);
+
public:
TestAcquireSharedNanosTimeoutRunnable(AbstractQueuedSynchronizerTest* parent, BooleanLatch* latch) :
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/LockSupportTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/LockSupportTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/LockSupportTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/LockSupportTest.cpp Tue Nov 27 20:32:53 2012
@@ -47,6 +47,11 @@ namespace {
LockSupportTest* parent;
+ private:
+
+ ParkTestThread(const ParkTestThread&);
+ ParkTestThread operator= (const ParkTestThread&);
+
public:
ParkTestThread(LockSupportTest* parent) : Thread(), parent(parent) {}
@@ -87,6 +92,11 @@ namespace {
LockSupportTest* parent;
+ private:
+
+ ParkTest2Thread(const ParkTest2Thread&);
+ ParkTest2Thread operator= (const ParkTest2Thread&);
+
public:
ParkTest2Thread(LockSupportTest* parent) : Thread(), parent(parent) {}
@@ -134,6 +144,11 @@ namespace {
LockSupportTest* parent;
+ private:
+
+ Park3TestThread(const Park3TestThread&);
+ Park3TestThread operator= (const Park3TestThread&);
+
public:
Park3TestThread(LockSupportTest* parent) : Thread(), parent(parent) {}
@@ -160,7 +175,7 @@ void LockSupportTest::testPark3() {
t.interrupt();
t.join();
}
- catch(Exception e) {
+ catch(Exception& e) {
unexpectedException();
}
}
@@ -174,6 +189,11 @@ namespace {
LockSupportTest* parent;
Mutex* lock;
+ private:
+
+ Park4TestThread(const Park4TestThread&);
+ Park4TestThread operator= (const Park4TestThread&);
+
public:
Park4TestThread(LockSupportTest* parent, Mutex* lock) : Thread(), parent(parent), lock(lock) {}
@@ -218,6 +238,11 @@ namespace {
LockSupportTest* parent;
+ private:
+
+ ParkNanosTestThread(const ParkNanosTestThread&);
+ ParkNanosTestThread operator= (const ParkNanosTestThread&);
+
public:
ParkNanosTestThread(LockSupportTest* parent) : Thread(), parent(parent) {}
@@ -255,6 +280,11 @@ namespace {
LockSupportTest* parent;
+ private:
+
+ ParkUntilTestThread(const ParkUntilTestThread&);
+ ParkUntilTestThread operator= (const ParkUntilTestThread&);
+
public:
ParkUntilTestThread(LockSupportTest* parent) : Thread(), parent(parent) {}
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/ReentrantLockTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/ReentrantLockTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/ReentrantLockTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/ReentrantLockTest.cpp Tue Nov 27 20:32:53 2012
@@ -42,6 +42,11 @@ namespace {
ReentrantLock* lock;
ReentrantLockTest* parent;
+ private:
+
+ InterruptibleLockRunnable(const InterruptibleLockRunnable&);
+ InterruptibleLockRunnable operator= (const InterruptibleLockRunnable&);
+
public:
InterruptibleLockRunnable(ReentrantLock* lock, ReentrantLockTest* parent) :
@@ -61,6 +66,11 @@ namespace {
ReentrantLock* lock;
ReentrantLockTest* parent;
+ private:
+
+ InterruptedLockRunnable(const InterruptedLockRunnable&);
+ InterruptedLockRunnable operator= (const InterruptedLockRunnable&);
+
public:
InterruptedLockRunnable(ReentrantLock* lock, ReentrantLockTest* parent) :
@@ -96,6 +106,11 @@ namespace {
Condition* c;
Mutex monitor;
+ private:
+
+ UninterruptableThread(const UninterruptableThread&);
+ UninterruptableThread operator= (const UninterruptableThread&);
+
public:
volatile bool canAwake;
@@ -103,7 +118,7 @@ namespace {
volatile bool lockStarted;
UninterruptableThread(ReentrantLock* lock, Condition* c) :
- Thread(), lock(lock), c(c), canAwake(false), interrupted(false), lockStarted(false) {
+ Thread(), lock(lock), c(c), monitor(), canAwake(false), interrupted(false), lockStarted(false) {
}
virtual ~UninterruptableThread() {}
@@ -368,6 +383,11 @@ namespace {
ReentrantLock* lock;
ReentrantLockTest* parent;
+ private:
+
+ TestInterruptedException2Runnable(const TestInterruptedException2Runnable&);
+ TestInterruptedException2Runnable operator= (const TestInterruptedException2Runnable&);
+
public:
TestInterruptedException2Runnable(ReentrantLock* lock, ReentrantLockTest* parent) :
@@ -410,6 +430,11 @@ namespace {
ReentrantLock* lock;
ReentrantLockTest* parent;
+ private:
+
+ TestTryLockWhenLockedRunnable(const TestTryLockWhenLockedRunnable&);
+ TestTryLockWhenLockedRunnable operator= (const TestTryLockWhenLockedRunnable&);
+
public:
TestTryLockWhenLockedRunnable(ReentrantLock* lock, ReentrantLockTest* parent) :
@@ -449,6 +474,11 @@ namespace {
ReentrantLock* lock;
ReentrantLockTest* parent;
+ private:
+
+ TestTryLockTimeoutRunnable(const TestTryLockTimeoutRunnable&);
+ TestTryLockTimeoutRunnable operator= (const TestTryLockTimeoutRunnable&);
+
public:
TestTryLockTimeoutRunnable(ReentrantLock* lock, ReentrantLockTest* parent) :
@@ -506,6 +536,11 @@ namespace {
ReentrantLock* lock;
ReentrantLockTest* parent;
+ private:
+
+ TestIsLockedRunnable(const TestIsLockedRunnable&);
+ TestIsLockedRunnable operator= (const TestIsLockedRunnable&);
+
public:
TestIsLockedRunnable(ReentrantLock* lock, ReentrantLockTest* parent) :
@@ -667,6 +702,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestAwaitRunnable(const TestAwaitRunnable&);
+ TestAwaitRunnable operator= (const TestAwaitRunnable&);
+
public:
TestAwaitRunnable(ReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -835,6 +875,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestHasWaitersRunnable(const TestHasWaitersRunnable&);
+ TestHasWaitersRunnable operator= (const TestHasWaitersRunnable&);
+
public:
TestHasWaitersRunnable(ReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -893,6 +938,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestGetWaitQueueLengthRunnable1(const TestGetWaitQueueLengthRunnable1&);
+ TestGetWaitQueueLengthRunnable1 operator= (const TestGetWaitQueueLengthRunnable1&);
+
public:
TestGetWaitQueueLengthRunnable1(ReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -919,6 +969,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestGetWaitQueueLengthRunnable2(const TestGetWaitQueueLengthRunnable2&);
+ TestGetWaitQueueLengthRunnable2 operator= (const TestGetWaitQueueLengthRunnable2&);
+
public:
TestGetWaitQueueLengthRunnable2(ReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -983,6 +1038,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestGetWaitingThreadsRunnable1(const TestGetWaitingThreadsRunnable1&);
+ TestGetWaitingThreadsRunnable1 operator= (const TestGetWaitingThreadsRunnable1&);
+
public:
TestGetWaitingThreadsRunnable1(PublicReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -1008,6 +1068,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestGetWaitingThreadsRunnable2(const TestGetWaitingThreadsRunnable2&);
+ TestGetWaitingThreadsRunnable2 operator= (const TestGetWaitingThreadsRunnable2&);
+
public:
TestGetWaitingThreadsRunnable2(PublicReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -1106,6 +1171,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestAwaitInterruptRunnable(const TestAwaitInterruptRunnable&);
+ TestAwaitInterruptRunnable operator= (const TestAwaitInterruptRunnable&);
+
public:
TestAwaitInterruptRunnable(ReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -1153,6 +1223,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestAwaitNanosInterruptRunnable(const TestAwaitNanosInterruptRunnable&);
+ TestAwaitNanosInterruptRunnable operator= (const TestAwaitNanosInterruptRunnable&);
+
public:
TestAwaitNanosInterruptRunnable(ReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -1200,6 +1275,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestAwaitUntilInterruptRunnable(const TestAwaitUntilInterruptRunnable&);
+ TestAwaitUntilInterruptRunnable operator= (const TestAwaitUntilInterruptRunnable&);
+
public:
TestAwaitUntilInterruptRunnable(ReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -1248,6 +1328,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestSignalAllRunnable(const TestSignalAllRunnable&);
+ TestSignalAllRunnable operator= (const TestSignalAllRunnable&);
+
public:
TestSignalAllRunnable(ReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -1302,6 +1387,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestAwaitLockCountRunnable1(const TestAwaitLockCountRunnable1&);
+ TestAwaitLockCountRunnable1 operator= (const TestAwaitLockCountRunnable1&);
+
public:
TestAwaitLockCountRunnable1(ReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
@@ -1328,6 +1418,11 @@ namespace {
Condition* condition;
ReentrantLockTest* parent;
+ private:
+
+ TestAwaitLockCountRunnable2(const TestAwaitLockCountRunnable2&);
+ TestAwaitLockCountRunnable2 operator= (const TestAwaitLockCountRunnable2&);
+
public:
TestAwaitLockCountRunnable2(ReentrantLock* lock, Condition* condition, ReentrantLockTest* parent) :
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/ReentrantReadWriteLockTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/ReentrantReadWriteLockTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/ReentrantReadWriteLockTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/concurrent/locks/ReentrantReadWriteLockTest.cpp Tue Nov 27 20:32:53 2012
@@ -35,6 +35,11 @@ namespace {
const int SIZEVAL = 256;
class InterruptibleLockRunnable : public Runnable {
+ private:
+
+ InterruptibleLockRunnable(const InterruptibleLockRunnable&);
+ InterruptibleLockRunnable operator= (const InterruptibleLockRunnable&);
+
public:
ReentrantReadWriteLockTest* test;
@@ -53,6 +58,11 @@ namespace {
};
class InterruptedLockRunnable : public Runnable {
+ private:
+
+ InterruptedLockRunnable(const InterruptedLockRunnable&);
+ InterruptedLockRunnable operator= (const InterruptedLockRunnable&);
+
public:
ReentrantReadWriteLockTest* test;
@@ -185,6 +195,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteLockInterruptiblyInterruptedRunnable(const TestWriteLockInterruptiblyInterruptedRunnable&);
+ TestWriteLockInterruptiblyInterruptedRunnable operator= (const TestWriteLockInterruptiblyInterruptedRunnable&);
+
public:
TestWriteLockInterruptiblyInterruptedRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -231,6 +246,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteTryLockInterruptedRunnable(const TestWriteTryLockInterruptedRunnable&);
+ TestWriteTryLockInterruptedRunnable operator= (const TestWriteTryLockInterruptedRunnable&);
+
public:
TestWriteTryLockInterruptedRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -273,6 +293,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestReadLockInterruptiblyInterruptedRunnable(const TestReadLockInterruptiblyInterruptedRunnable&);
+ TestReadLockInterruptiblyInterruptedRunnable operator= (const TestReadLockInterruptiblyInterruptedRunnable&);
+
public:
TestReadLockInterruptiblyInterruptedRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -317,6 +342,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestReadTryLockInterruptedRunnable(const TestReadTryLockInterruptedRunnable&);
+ TestReadTryLockInterruptedRunnable operator= (const TestReadTryLockInterruptedRunnable&);
+
public:
TestReadTryLockInterruptedRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -359,6 +389,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteTryLockWhenLockedRunnable(const TestWriteTryLockWhenLockedRunnable&);
+ TestWriteTryLockWhenLockedRunnable operator= (const TestWriteTryLockWhenLockedRunnable&);
+
public:
TestWriteTryLockWhenLockedRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -397,6 +432,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestReadTryLockWhenLockedRunnable(const TestReadTryLockWhenLockedRunnable&);
+ TestReadTryLockWhenLockedRunnable operator= (const TestReadTryLockWhenLockedRunnable&);
+
public:
TestReadTryLockWhenLockedRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -435,6 +475,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestMultipleReadLocksRunnable(const TestMultipleReadLocksRunnable&);
+ TestMultipleReadLocksRunnable operator= (const TestMultipleReadLocksRunnable&);
+
public:
TestMultipleReadLocksRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -473,6 +518,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteAfterMultipleReadLocksRunnable1(const TestWriteAfterMultipleReadLocksRunnable1&);
+ TestWriteAfterMultipleReadLocksRunnable1 operator= (const TestWriteAfterMultipleReadLocksRunnable1&);
+
public:
TestWriteAfterMultipleReadLocksRunnable1(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -491,6 +541,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteAfterMultipleReadLocksRunnable2(const TestWriteAfterMultipleReadLocksRunnable2&);
+ TestWriteAfterMultipleReadLocksRunnable2 operator= (const TestWriteAfterMultipleReadLocksRunnable2&);
+
public:
TestWriteAfterMultipleReadLocksRunnable2(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -538,6 +593,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestReadAfterWriteLockRunnable(const TestReadAfterWriteLockRunnable&);
+ TestReadAfterWriteLockRunnable operator= (const TestReadAfterWriteLockRunnable&);
+
public:
TestReadAfterWriteLockRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -593,6 +653,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestReadHoldingWriteLockRunnable2(const TestReadHoldingWriteLockRunnable2&);
+ TestReadHoldingWriteLockRunnable2 operator= (const TestReadHoldingWriteLockRunnable2&);
+
public:
TestReadHoldingWriteLockRunnable2(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -642,6 +707,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestReadHoldingWriteLockRunnable3(const TestReadHoldingWriteLockRunnable3&);
+ TestReadHoldingWriteLockRunnable3 operator= (const TestReadHoldingWriteLockRunnable3&);
+
public:
TestReadHoldingWriteLockRunnable3(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -691,6 +761,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteHoldingWriteLock4Runnable(const TestWriteHoldingWriteLock4Runnable&);
+ TestWriteHoldingWriteLock4Runnable operator= (const TestWriteHoldingWriteLock4Runnable&);
+
public:
TestWriteHoldingWriteLock4Runnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -750,6 +825,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestReadHoldingWriteLockFair2Runnable(const TestReadHoldingWriteLockFair2Runnable&);
+ TestReadHoldingWriteLockFair2Runnable operator= (const TestReadHoldingWriteLockFair2Runnable&);
+
public:
TestReadHoldingWriteLockFair2Runnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -799,6 +879,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestReadHoldingWriteLockFair3Runnable(const TestReadHoldingWriteLockFair3Runnable&);
+ TestReadHoldingWriteLockFair3Runnable operator= (const TestReadHoldingWriteLockFair3Runnable&);
+
public:
TestReadHoldingWriteLockFair3Runnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -848,6 +933,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteHoldingWriteLockFair4Runnable(const TestWriteHoldingWriteLockFair4Runnable&);
+ TestWriteHoldingWriteLockFair4Runnable operator= (const TestWriteHoldingWriteLockFair4Runnable&);
+
public:
TestWriteHoldingWriteLockFair4Runnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -899,6 +989,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestTryLockWhenReadLockedRunnable(const TestTryLockWhenReadLockedRunnable&);
+ TestTryLockWhenReadLockedRunnable operator= (const TestTryLockWhenReadLockedRunnable&);
+
public:
TestTryLockWhenReadLockedRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -937,6 +1032,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteTryLockWhenReadLockedRunnable(const TestWriteTryLockWhenReadLockedRunnable&);
+ TestWriteTryLockWhenReadLockedRunnable operator= (const TestWriteTryLockWhenReadLockedRunnable&);
+
public:
TestWriteTryLockWhenReadLockedRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -974,6 +1074,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestTryLockWhenReadLockedFairRunnable(const TestTryLockWhenReadLockedFairRunnable&);
+ TestTryLockWhenReadLockedFairRunnable operator= (const TestTryLockWhenReadLockedFairRunnable&);
+
public:
TestTryLockWhenReadLockedFairRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -1012,6 +1117,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteTryLockWhenReadLockedFairRunnable(const TestWriteTryLockWhenReadLockedFairRunnable&);
+ TestWriteTryLockWhenReadLockedFairRunnable operator= (const TestWriteTryLockWhenReadLockedFairRunnable&);
+
public:
TestWriteTryLockWhenReadLockedFairRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -1049,6 +1159,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteTryLockTimeoutRunnable(const TestWriteTryLockTimeoutRunnable&);
+ TestWriteTryLockTimeoutRunnable operator= (const TestWriteTryLockTimeoutRunnable&);
+
public:
TestWriteTryLockTimeoutRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -1090,6 +1205,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestReadTryLockTimeoutRunnable(const TestReadTryLockTimeoutRunnable&);
+ TestReadTryLockTimeoutRunnable operator= (const TestReadTryLockTimeoutRunnable&);
+
public:
TestReadTryLockTimeoutRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -1131,6 +1251,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestWriteLockInterruptiblyRunnable(const TestWriteLockInterruptiblyRunnable&);
+ TestWriteLockInterruptiblyRunnable operator= (const TestWriteLockInterruptiblyRunnable&);
+
public:
TestWriteLockInterruptiblyRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -1179,6 +1304,11 @@ namespace {
ReentrantReadWriteLockTest* test;
ReentrantReadWriteLock* lock;
+ private:
+
+ TestReadLockInterruptiblyRunnable(const TestReadLockInterruptiblyRunnable&);
+ TestReadLockInterruptiblyRunnable operator= (const TestReadLockInterruptiblyRunnable&);
+
public:
TestReadLockInterruptiblyRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock) :
@@ -1301,6 +1431,11 @@ namespace {
ReentrantReadWriteLock* lock;
Condition* cond;
+ private:
+
+ TestAwaitRunnable(const TestAwaitRunnable&);
+ TestAwaitRunnable operator= (const TestAwaitRunnable&);
+
public:
TestAwaitRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock, Condition* cond) :
@@ -1349,6 +1484,11 @@ namespace {
decaf::util::concurrent::locks::Lock& lock;
Condition* cond;
+ private:
+
+ UninterruptableThread(const UninterruptableThread&);
+ UninterruptableThread operator= (const UninterruptableThread&);
+
public:
volatile bool canAwake;
@@ -1418,6 +1558,11 @@ namespace {
ReentrantReadWriteLock* lock;
Condition* cond;
+ private:
+
+ TestAwaitInterruptRunnable(const TestAwaitInterruptRunnable&);
+ TestAwaitInterruptRunnable operator= (const TestAwaitInterruptRunnable&);
+
public:
TestAwaitInterruptRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock, Condition* cond) :
@@ -1465,6 +1610,11 @@ namespace {
ReentrantReadWriteLock* lock;
Condition* cond;
+ private:
+
+ TestAwaitNanosInterruptRunnable(const TestAwaitNanosInterruptRunnable&);
+ TestAwaitNanosInterruptRunnable operator= (const TestAwaitNanosInterruptRunnable&);
+
public:
TestAwaitNanosInterruptRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock, Condition* cond) :
@@ -1511,6 +1661,11 @@ namespace {
ReentrantReadWriteLock* lock;
Condition* cond;
+ private:
+
+ TestAwaitUntilInterruptRunnable(const TestAwaitUntilInterruptRunnable&);
+ TestAwaitUntilInterruptRunnable operator= (const TestAwaitUntilInterruptRunnable&);
+
public:
TestAwaitUntilInterruptRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock, Condition* cond) :
@@ -1558,6 +1713,11 @@ namespace {
ReentrantReadWriteLock* lock;
Condition* cond;
+ private:
+
+ TestSignalAllRunnable(const TestSignalAllRunnable&);
+ TestSignalAllRunnable operator= (const TestSignalAllRunnable&);
+
public:
TestSignalAllRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock, Condition* cond) :
@@ -1865,6 +2025,11 @@ namespace {
ReentrantReadWriteLock* lock;
Condition* cond;
+ private:
+
+ TestHasWaitersRunnable(const TestHasWaitersRunnable&);
+ TestHasWaitersRunnable operator= (const TestHasWaitersRunnable&);
+
public:
TestHasWaitersRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock, Condition* cond) :
@@ -1922,6 +2087,11 @@ namespace {
ReentrantReadWriteLock* lock;
Condition* cond;
+ private:
+
+ TestGetWaitQueueLengthRunnable(const TestGetWaitQueueLengthRunnable&);
+ TestGetWaitQueueLengthRunnable operator= (const TestGetWaitQueueLengthRunnable&);
+
public:
TestGetWaitQueueLengthRunnable(ReentrantReadWriteLockTest* test, ReentrantReadWriteLock* lock, Condition* cond) :
@@ -1979,6 +2149,11 @@ namespace {
PublicReentrantReadWriteLock* lock;
Condition* cond;
+ private:
+
+ TestGetWaitingThreadsRunnable1(const TestGetWaitingThreadsRunnable1&);
+ TestGetWaitingThreadsRunnable1 operator= (const TestGetWaitingThreadsRunnable1&);
+
public:
TestGetWaitingThreadsRunnable1(ReentrantReadWriteLockTest* test, PublicReentrantReadWriteLock* lock, Condition* cond) :
@@ -2005,6 +2180,11 @@ namespace {
PublicReentrantReadWriteLock* lock;
Condition* cond;
+ private:
+
+ TestGetWaitingThreadsRunnable2(const TestGetWaitingThreadsRunnable2&);
+ TestGetWaitingThreadsRunnable2 operator= (const TestGetWaitingThreadsRunnable2&);
+
public:
TestGetWaitingThreadsRunnable2(ReentrantReadWriteLockTest* test, PublicReentrantReadWriteLock* lock, Condition* cond) :
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/DeflaterOutputStreamTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/DeflaterOutputStreamTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/DeflaterOutputStreamTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/DeflaterOutputStreamTest.cpp Tue Nov 27 20:32:53 2012
@@ -43,7 +43,7 @@ using namespace decaf::util;
using namespace decaf::util::zip;
////////////////////////////////////////////////////////////////////////////////
-namespace{
+ namespace {
class MyDeflaterOutputStream : public DeflaterOutputStream {
private:
@@ -52,22 +52,18 @@ namespace{
public:
- MyDeflaterOutputStream( OutputStream* out ) : DeflaterOutputStream( out ) {
- this->deflateFlag = false;
- }
-
- MyDeflaterOutputStream( OutputStream* out, Deflater* defl ) :
- DeflaterOutputStream( out, defl ) {
+ MyDeflaterOutputStream(OutputStream* out) : DeflaterOutputStream(out), deflateFlag(false) {}
- this->deflateFlag = false;
+ MyDeflaterOutputStream(OutputStream* out, Deflater* defl) :
+ DeflaterOutputStream(out, defl), deflateFlag(false) {
}
- MyDeflaterOutputStream( OutputStream* out, Deflater* defl, int size ) :
- DeflaterOutputStream( out, defl, size ) {
-
- this->deflateFlag = false;
+ MyDeflaterOutputStream(OutputStream* out, Deflater* defl, int size) :
+ DeflaterOutputStream(out, defl, size), deflateFlag(false) {
}
+ virtual ~MyDeflaterOutputStream() {}
+
std::vector<unsigned char>& getProtectedBuf() {
return buf;
}
@@ -88,7 +84,7 @@ namespace{
}
////////////////////////////////////////////////////////////////////////////////
-DeflaterOutputStreamTest::DeflaterOutputStreamTest() {
+DeflaterOutputStreamTest::DeflaterOutputStreamTest() : outputBuffer() {
}
////////////////////////////////////////////////////////////////////////////////
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterInputStreamTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterInputStreamTest.cpp?rev=1414381&r1=1414380&r2=1414381&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterInputStreamTest.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/zip/InflaterInputStreamTest.cpp Tue Nov 27 20:32:53 2012
@@ -98,6 +98,8 @@ namespace {
: InflaterInputStream( in, infl, size ) {
}
+ virtual ~MyInflaterInputStream() {}
+
void myFill() {
fill();
}
@@ -105,7 +107,7 @@ namespace {
}
////////////////////////////////////////////////////////////////////////////////
-InflaterInputStreamTest::InflaterInputStreamTest() {
+InflaterInputStreamTest::InflaterInputStreamTest() : deflatedData(), inputBuffer() {
}
////////////////////////////////////////////////////////////////////////////////