activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject 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...
Date Tue, 27 Nov 2012 20:33:10 GMT
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() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////



Mime
View raw message