diff -r 000000000000 -r 671dee74050a searchengine/util/tsrc/cpixtoolsunittest/src/mutextest.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/searchengine/util/tsrc/cpixtoolsunittest/src/mutextest.cpp	Mon Apr 19 14:40:16 2010 +0300
@@ -0,0 +1,283 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+#include <unistd.h>
+
+#include <memory>
+#include <string.h>
+
+#include "itk.h"
+
+#include "cpixsynctools.h"
+
+
+void testMutex(Itk::TestMgr * )
+{
+    using namespace Cpt;
+
+    Mutex
+        mutex;
+
+    SyncRegion
+        sr(mutex);
+}
+
+
+void testRecursiveMutex(Itk::TestMgr * )
+{
+    using namespace Cpt;
+
+    Mutex
+        mutex(true);
+
+    SyncRegion
+        sr1(mutex);
+
+    SyncRegion
+        sr2(mutex);
+}
+
+
+void testMultiSyncRegion(Itk::TestMgr * )
+{
+    using namespace Cpt;
+
+    Mutex
+        mutex1,
+        mutex2(true),
+        mutex3;
+
+    {
+        MultiSyncRegion
+            msr(4);
+        
+        msr.lock(mutex1);
+        msr.lock(mutex2);
+        msr.lock(mutex3);
+        msr.lock(mutex2);
+    }
+
+    SyncRegion
+        sr(mutex1);
+
+    SyncRegion
+        sr1(mutex2);
+
+    SyncRegion
+        sr2(mutex3);
+}
+
+
+void testSyncExc(Itk::TestMgr * mgr)
+{
+    pthread_mutex_t
+        mutex;
+
+    // kept uninitialized on purpose!
+
+    try
+        {
+            Cpt::Impl::SyncRegion_::lockMutex(&mutex);
+
+            ITK_EXPECT(mgr,
+                       false,
+                       "Locking uninitalized mutex should have failed");
+        }
+    catch (std::exception & exc)
+        {
+            printf("Locking unitialized mutex have failed (as should): %s\n",
+                   exc.what());
+        }
+
+    try
+        {
+            Cpt::Impl::SyncRegion_::unlockMutex(&mutex);
+
+            ITK_EXPECT(mgr,
+                       false,
+                       "Unlocking uninitalized mutex should have failed");
+        }
+    catch (std::exception & exc)
+        {
+            printf("Unlocking unitialized mutex have failed (as should): %s\n",
+                   exc.what());
+        }
+
+    Cpt::Impl::SyncRegion_::initMutex(&mutex);
+
+    try
+        {
+            Cpt::Impl::SyncRegion_::unlockMutex(&mutex);
+
+            // TODO this should be ITK_EXPECT - why does NOT it fail?
+            printf("Unlocking initialized but non-locked mutex should have failed\n");
+        }
+    catch (std::exception & exc)
+        {
+            printf("Unlocking initialized but non-locked mutex have failed (as should): %s\n",
+                   exc.what());
+        }
+
+    try
+        {
+            {
+                Cpt::Impl::SyncRegion_
+                    sr(&mutex);
+            }
+
+            printf("Locked and unlocked mutex");
+        }
+    catch (std::exception & exc)
+        {
+            ITK_EXPECT(mgr,
+                       false,
+                       "Failed to lock and unlock mutex: %s",
+                       exc.what());
+        }
+
+    Cpt::Impl::SyncRegion_::destroyMutex(&mutex);
+}
+
+
+/**
+ * Test "SyncExc2" tries to create a situation where a thread that
+ * does not own the lock tries to unlock the mutex (should fail).
+ */
+struct StupidUnlock
+{
+    pthread_mutex_t    * mutex_;
+    Itk::TestMgr       * mgr_;
+};
+
+
+void * StupidThreadFunc(void * param)
+{
+    printf("# SyncExc2 / StupidThread BEGIN.\n");
+
+    StupidUnlock
+        * p = reinterpret_cast<StupidUnlock*>(param);
+
+    try
+        {
+            Cpt::Impl::SyncRegion_::unlockMutex(p->mutex_);
+
+            // TODO this should be ITK_EXPECT - why does NOT it fail?
+            printf("# Unlocking mutex that is locked by another thread should fail (imho) - but it succeeds on both winscw and arm.\n");
+        }
+    catch (std::exception & exc)
+        {
+            printf("# Unlocking mutex owned by another thread have failed (as should): %s\n",
+                   exc.what());
+        }
+    
+    printf("# SyncExc2 / StupidThread END.\n");
+
+    return NULL;
+}
+
+
+void testSyncExc2(Itk::TestMgr * mgr)
+{
+    pthread_mutex_t
+        mutex;
+
+    Cpt::Impl::SyncRegion_::initMutex(&mutex);
+
+    {
+        Cpt::Impl::SyncRegion_
+            sr(&mutex);
+
+        // here we create a thread that will try to unlock the mutex
+        // held by this thread - it should fail
+        StupidUnlock
+            stupidUnlock = {
+            &mutex,
+            mgr
+        };
+        
+        pthread_t
+            stupidThread;
+        
+        int
+            result = pthread_create(&stupidThread,
+                                    NULL,
+                                    &StupidThreadFunc,
+                                    &stupidUnlock);
+        
+        ITK_ASSERT(mgr,
+                   result == 0,
+                   "Could not start stupid thread: %d",
+                   result);
+        
+        printf("Sleep(1) ...\n");
+
+        sleep(1);
+        
+        printf("... awake(1)\n");
+
+        result = pthread_join(stupidThread,
+                              NULL);
+        
+        printf("has joined stupid thread, unlocking mutex\n");
+    }
+
+    Cpt::Impl::SyncRegion_::destroyMutex(&mutex);
+
+    printf("SyncExc2 test done.\n");
+}
+
+
+
+Itk::TesterBase * CreateMutexTests()
+{
+    using namespace Itk;
+
+    SuiteTester
+        * mutexTests = new SuiteTester("mutex");
+
+#define TEST "mutex"
+    mutexTests->add(TEST,
+                    testMutex);
+#undef TEST
+
+#define TEST "recursivemutex"
+    mutexTests->add(TEST,
+                    testRecursiveMutex);
+#undef TEST
+
+#define TEST "multisyncregion"
+    mutexTests->add(TEST,
+                    testMultiSyncRegion);
+#undef TEST
+
+#define TEST "syncexc"
+    mutexTests->add(TEST,
+                    testSyncExc,
+                    TEST);
+#undef TEST
+
+#define TEST "syncexc2"
+    mutexTests->add(TEST,
+                    testSyncExc2,
+                    TEST);
+#undef TEST
+
+
+    // ... add more tests to suite
+    
+    return mutexTests;
+    
+}