Index: libcfa/src/bits/weakso_locks.cfa
===================================================================
--- libcfa/src/bits/weakso_locks.cfa	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ libcfa/src/bits/weakso_locks.cfa	(revision ca33b152dd74088cc759233fe5fe756db0550bf5)
@@ -18,12 +18,13 @@
 #include "bits/weakso_locks.hfa"
 
-void  ?{}( blocking_lock &, bool, bool ) {}
-void ^?{}( blocking_lock & ) {}
+void  ?{}( blocking_lock & this, bool multi_acquisition, bool strict_owner ) {}
+void ^?{}( blocking_lock & this ) {}
 
-void lock( blocking_lock & ) {}
-bool try_lock( blocking_lock & ) { return false; }
-void unlock( blocking_lock & ) {}
-void on_notify( blocking_lock &, struct $thread * ) {}
-size_t on_wait( blocking_lock & ) {}
-void on_wakeup( blocking_lock &, size_t ) {}
-size_t wait_count( blocking_lock & ) { return 0; }
+void lock( blocking_lock & this ) {}
+bool try_lock( blocking_lock & this ) { return false; }
+void unlock( blocking_lock & this ) {}
+void on_notify( blocking_lock & this, struct $thread * t ) {}
+void on_wait( blocking_lock & this ) {}
+size_t wait_count( blocking_lock & this ) { return 0; }
+void set_recursion_count( blocking_lock & this, size_t recursion ) {}
+size_t get_recursion_count( blocking_lock & this ) { return 0; }
Index: libcfa/src/bits/weakso_locks.hfa
===================================================================
--- libcfa/src/bits/weakso_locks.hfa	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ libcfa/src/bits/weakso_locks.hfa	(revision ca33b152dd74088cc759233fe5fe756db0550bf5)
@@ -56,7 +56,8 @@
 void unlock( blocking_lock & this ) OPTIONAL_THREAD;
 void on_notify( blocking_lock & this, struct $thread * t ) OPTIONAL_THREAD;
-size_t on_wait( blocking_lock & this ) OPTIONAL_THREAD;
-void on_wakeup( blocking_lock & this, size_t ) OPTIONAL_THREAD;
+void on_wait( blocking_lock & this ) OPTIONAL_THREAD;
 size_t wait_count( blocking_lock & this ) OPTIONAL_THREAD;
+void set_recursion_count( blocking_lock & this, size_t recursion ) OPTIONAL_THREAD;
+size_t get_recursion_count( blocking_lock & this ) OPTIONAL_THREAD;
 
 //----------
@@ -71,5 +72,6 @@
 static inline bool   try_lock ( multiple_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); }
 static inline void   unlock   ( multiple_acquisition_lock & this ) { unlock  ( (blocking_lock &)this ); }
-static inline size_t on_wait  ( multiple_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
-static inline void   on_wakeup( multiple_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
+static inline void   on_wait  ( multiple_acquisition_lock & this ) { on_wait ( (blocking_lock &)this ); }
 static inline void   on_notify( multiple_acquisition_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
+static inline void   set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
+static inline size_t get_recursion_count( multiple_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }
Index: libcfa/src/concurrency/locks.cfa
===================================================================
--- libcfa/src/concurrency/locks.cfa	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ libcfa/src/concurrency/locks.cfa	(revision ca33b152dd74088cc759233fe5fe756db0550bf5)
@@ -134,6 +134,5 @@
 	lock( lock __cfaabi_dbg_ctx2 );
 	/* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
-	/* paranoid */ verifyf( owner == active_thread() || !strict_owner , "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
-	/* paranoid */ verifyf( recursion_count == 1 || multi_acquisition, "Thread %p attempted to release owner lock %p which is not recursive but has a recursive count of %zu", active_thread(), &this, recursion_count );
+	/* paranoid */ verifyf( owner == active_thread() || !strict_owner, "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
 
 	// if recursion count is zero release lock and set new owner if one is waiting
@@ -147,4 +146,12 @@
 size_t wait_count( blocking_lock & this ) with( this ) {
 	return wait_count;
+}
+
+void set_recursion_count( blocking_lock & this, size_t recursion ) with( this ) {
+	recursion_count = recursion;
+}
+
+size_t get_recursion_count( blocking_lock & this ) with( this ) {
+	return recursion_count;
 }
 
@@ -166,18 +173,11 @@
 }
 
-size_t on_wait( blocking_lock & this ) with( this ) {
+void on_wait( blocking_lock & this ) with( this ) {
 	lock( lock __cfaabi_dbg_ctx2 );
 	/* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
 	/* paranoid */ verifyf( owner == active_thread() || !strict_owner, "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
 
-	size_t ret = recursion_count;
-
 	pop_and_set_new_owner( this );
 	unlock( lock );
-	return ret;
-}
-
-void on_wakeup( blocking_lock & this, size_t recursion ) with( this ) {
-	recursion_count = recursion;
 }
 
@@ -274,10 +274,5 @@
 	}
 
-	bool empty( condition_variable(L) & this ) with(this) {
-		lock( lock __cfaabi_dbg_ctx2 );
-		bool ret = empty(blocked_threads);
-		unlock( lock );
-		return ret;
-	}
+	bool empty( condition_variable(L) & this ) with(this) { return empty(blocked_threads); }
 
 	int counter( condition_variable(L) & this ) with(this) { return count; }
@@ -290,5 +285,6 @@
 		if (i->lock) {
 			// if lock was passed get recursion count to reset to after waking thread
-			recursion_count = on_wait( *i->lock );
+			recursion_count = get_recursion_count(*i->lock);
+			on_wait( *i->lock );
 		}
 		return recursion_count;
@@ -305,5 +301,5 @@
 
 		// resets recursion count here after waking
-		if (i.lock) on_wakeup(*i.lock, recursion_count);
+		if (i.lock) set_recursion_count(*i.lock, recursion_count);
 	}
 
@@ -327,5 +323,5 @@
 
 		// resets recursion count here after waking
-		if (info.lock) on_wakeup(*info.lock, recursion_count);
+		if (info.lock) set_recursion_count(*info.lock, recursion_count);
 	}
 
@@ -377,5 +373,5 @@
 }
 
-$thread * V (semaphore & this, const bool doUnpark ) with( this ) {
+bool V(semaphore & this) with( this ) {
 	$thread * thrd = 0p;
 	lock( lock __cfaabi_dbg_ctx2 );
@@ -389,11 +385,6 @@
 
 	// make new owner
-	if( doUnpark ) unpark( thrd );
-
-	return thrd;
-}
-
-bool V(semaphore & this) with( this ) {
-	$thread * thrd = V(this, true);
+	unpark( thrd );
+
 	return thrd != 0p;
 }
Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ libcfa/src/concurrency/locks.hfa	(revision ca33b152dd74088cc759233fe5fe756db0550bf5)
@@ -39,4 +39,5 @@
 };
 
+static inline bool P(Semaphore0nary & this, $thread * thrd) __attribute__((artificial));
 static inline bool P(Semaphore0nary & this, $thread * thrd) {
 	/* paranoid */ verify(!(thrd->seqable.next));
@@ -47,4 +48,5 @@
 }
 
+static inline bool P(Semaphore0nary & this) __attribute__((artificial));
 static inline bool P(Semaphore0nary & this) {
     $thread * thrd = active_thread();
@@ -54,4 +56,5 @@
 }
 
+static inline $thread * V(Semaphore0nary & this, const bool doUnpark = true) __attribute__((artificial));
 static inline $thread * V(Semaphore0nary & this, const bool doUnpark = true) {
 	$thread * next;
@@ -79,8 +82,5 @@
 
 	// returns true if no blocking needed
-	bool P(BinaryBenaphore & this) {
-		return __atomic_fetch_sub(&this.counter, 1, __ATOMIC_SEQ_CST) > 0;
-	}
-
+	bool P(BinaryBenaphore & this) { return __atomic_fetch_sub(&this.counter, 1, __ATOMIC_SEQ_CST) > 0; }
 	bool tryP(BinaryBenaphore & this) {
 		ssize_t c = this.counter;
@@ -115,10 +115,11 @@
 static inline void ?{}(ThreadBenaphore & this, one_t ) { (this.ben){ 1 }; }
 
-static inline bool P(ThreadBenaphore & this)              { return P(this.ben) ? false : P(this.sem); }
+static inline bool P(ThreadBenaphore & this)              { return /* P(this.ben) ? false : */ P(this.sem); }
+static inline bool P(ThreadBenaphore & this, $thread * t) { return /* P(this.ben) ? false : */ P(this.sem, t ); }
 static inline bool tryP(ThreadBenaphore & this)           { return tryP(this.ben); }
 static inline bool P(ThreadBenaphore & this, bool wait)   { return wait ? P(this) : tryP(this); }
 
 static inline $thread * V(ThreadBenaphore & this, const bool doUnpark = true) {
-	if (V(this.ben)) return 0p;
+	// if (V(this.ben)) return 0p;
 	return V(this.sem, doUnpark);
 }
@@ -137,5 +138,4 @@
 bool   V (semaphore & this);
 bool   V (semaphore & this, unsigned count);
-$thread * V (semaphore & this, bool );
 
 //----------
@@ -146,10 +146,11 @@
 static inline void  ?{}( single_acquisition_lock & this ) {((blocking_lock &)this){ false, false };}
 static inline void ^?{}( single_acquisition_lock & this ) {}
-static inline void   lock     ( single_acquisition_lock & this ) { lock    ( (blocking_lock &)this ); }
-static inline bool   try_lock ( single_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); }
-static inline void   unlock   ( single_acquisition_lock & this ) { unlock  ( (blocking_lock &)this ); }
-static inline size_t on_wait  ( single_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
-static inline void   on_wakeup( single_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
-static inline void   on_notify( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline void   lock      ( single_acquisition_lock & this ) { lock    ( (blocking_lock &)this ); }
+static inline bool   try_lock  ( single_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); }
+static inline void   unlock    ( single_acquisition_lock & this ) { unlock  ( (blocking_lock &)this ); }
+static inline void   on_wait   ( single_acquisition_lock & this ) { on_wait ( (blocking_lock &)this ); }
+static inline void   on_notify ( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline void   set_recursion_count( single_acquisition_lock & this, size_t recursion ) { set_recursion_count( (blocking_lock &)this, recursion ); }
+static inline size_t get_recursion_count( single_acquisition_lock & this ) { return get_recursion_count( (blocking_lock &)this ); }
 
 //----------
@@ -163,7 +164,8 @@
 static inline bool   try_lock ( owner_lock & this ) { return try_lock( (blocking_lock &)this ); }
 static inline void   unlock   ( owner_lock & this ) { unlock  ( (blocking_lock &)this ); }
-static inline size_t on_wait  ( owner_lock & this ) { return on_wait ( (blocking_lock &)this ); }
-static inline void   on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
+static inline void   on_wait  ( owner_lock & this ) { on_wait ( (blocking_lock &)this ); }
 static inline void   on_notify( owner_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline void   set_recursion_count( owner_lock & this, size_t recursion ) { set_recursion_count( (blocking_lock &)this, recursion ); }
+static inline size_t get_recursion_count( owner_lock & this ) { return get_recursion_count( (blocking_lock &)this ); }
 
 struct fast_lock {
@@ -177,5 +179,13 @@
 }
 
-static inline void lock( fast_lock & this ) __attribute__((artificial));
+static inline void $lock(fast_lock & this, $thread * thrd) {
+	/* paranoid */verify(thrd != this.owner);
+
+	for (;;) {
+		if ($try_lock(this, thrd)) return;
+		P(this.sem, thrd);
+	}
+}
+
 static inline void lock( fast_lock & this ) {
 	$thread * thrd = active_thread();
@@ -188,6 +198,5 @@
 }
 
-static inline bool try_lock( fast_lock & this ) __attribute__((artificial));
-static inline bool try_lock ( fast_lock & this ) {
+static inline void try_lock ( fast_lock & this ) {
 	$thread * thrd = active_thread();
 	/* paranoid */ verify(thrd != this.owner);
@@ -195,20 +204,27 @@
 }
 
-static inline $thread * unlock( fast_lock & this ) __attribute__((artificial));
-static inline $thread * unlock( fast_lock & this ) {
+static inline void unlock( fast_lock & this ) {
 	$thread * thrd = active_thread();
 	/* paranoid */ verify(thrd == this.owner);
-
-	// open 'owner' before unlocking anyone
-	// so new and unlocked threads don't park incorrectly.
-	// This may require additional fencing on ARM.
+	$thread * next = V(this.sem, false); // implicit fence
+	// open 'owner' only after fence
 	this.owner = 0p;
 
-	return V(this.sem, true);
-}
-
-static inline size_t on_wait( fast_lock & this ) { unlock(this); return 0; }
-static inline void on_wakeup( fast_lock & this, size_t ) { lock(this); }
-static inline void on_notify( fast_lock &, struct $thread * t ) { unpark(t); }
+	// Unpark the next person (can be 0p, unpark handles it)
+	unpark(next);
+}
+
+static inline void on_wait( fast_lock & this ) {
+	unlock(this);
+	#warning this is broken
+}
+
+static inline void on_notify( fast_lock & this, struct $thread * t ) {
+	$lock(this, t);
+	#warning this is broken
+}
+
+static inline void   set_recursion_count( fast_lock & this, size_t recursion ) {}
+static inline size_t get_recursion_count( fast_lock & this ) { return 0; }
 
 struct mcs_node {
@@ -244,8 +260,11 @@
 
 	// For synchronization locks to use when releasing
-	size_t on_wait( L & );
+	void on_wait( L & );
+
+	// to get recursion count for cond lock to reset after waking
+	size_t get_recursion_count( L & );
 
 	// to set recursion count after getting signalled;
-	void on_wakeup( L &, size_t recursion );
+	void set_recursion_count( L &, size_t recursion );
 };
 
Index: sts/concurrent/.expect/semaphore.txt
===================================================================
--- tests/concurrent/.expect/semaphore.txt	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ 	(revision )
@@ -1,3 +1,0 @@
-Starting
-Done!
-Match!
Index: sts/concurrent/semaphore.cfa
===================================================================
--- tests/concurrent/semaphore.cfa	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ 	(revision )
@@ -1,77 +1,0 @@
-#include <fstream.hfa>
-#include <locks.hfa>
-#include <thread.hfa>
-
-enum { num_blockers = 17, num_unblockers = 13 };
-
-void thrash() {
-	unsigned t[100];
-	for(i; 100) {
-		t[i] = 0xDEADBEEF;
-	}
-}
-
-ThreadBenaphore ben;
-
-// const unsigned int num_blocks = 25000;
-const unsigned int num_blocks = 5;
-
-thread Blocker {
-	size_t sum;
-};
-
-void main(Blocker & this) {
-	$thread * me = active_thread();
-	this.sum = 0;
-	for(num_blocks) {
-		this.sum += (unsigned)me;
-		thrash();
-		P(ben);
-		if(((thread&)this).seqable.next != 0p) sout | acquire |"Link not invalidated";
-		thrash();
-	}
-}
-
-thread Unblocker {
-	size_t sum;
-};
-
-void main(Unblocker & this) {
-	this.sum = 0;
-	LOOP: for() {
-		waitfor( ^?{} : this) {
-			break LOOP;
-		}
-		or else {}
-
-		$thread * t = V(ben, false);
-		if(t) {
-			this.sum += (unsigned)t;
-			unpark(t);
-		}
-		yield(random(10));
-	}
-}
-
-int main() {
-	size_t usum = 0;
-	size_t bsum = 0;
-
-	sout | "Starting";
-	{
-		Blocker   blockers  [num_blockers  ];
-		Unblocker unblockers[num_unblockers];
-
-		for(i;num_blockers) {
-			bsum += join(blockers[i]).sum;
-		}
-
-		sout | "Done!";
-
-		for(i;num_unblockers) {
-			usum += join(unblockers[i]).sum;
-		}
-	}
-	if(bsum == usum) sout | "Match!";
-	else sout | "No Match!" | usum | "!=" | bsum;
-}
Index: tests/concurrent/spinaphore.cfa
===================================================================
--- tests/concurrent/spinaphore.cfa	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ tests/concurrent/spinaphore.cfa	(revision ca33b152dd74088cc759233fe5fe756db0550bf5)
@@ -36,6 +36,8 @@
 	this.sum = 0;
 	for(num_blocks) {
+		// sout | "b P" | me;
 		P(sem);
 		if(((thread&)this).seqable.next != 0p) sout | "Link not invalidated";
+		// sout | "a P" | me;
 	}
 }
@@ -56,4 +58,5 @@
 		this.sum += (unsigned)b;
 		unpark(t);
+		// sout | "a V" | t;
 		yield(random(10));
 	}
Index: sts/unified_locking/.expect/fast.txt
===================================================================
--- tests/unified_locking/.expect/fast.txt	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ 	(revision )
@@ -1,3 +1,0 @@
-Starting
-Done!
-Match!
Index: tests/unified_locking/.expect/locks.txt
===================================================================
--- tests/unified_locking/.expect/locks.txt	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ tests/unified_locking/.expect/locks.txt	(revision ca33b152dd74088cc759233fe5fe756db0550bf5)
@@ -11,14 +11,10 @@
 Start Test 6: owner lock and condition variable 3 wait/notify all
 Done Test 6
-Start Test 7: fast lock and condition variable single wait/notify
+Start Test 7: multi acquisiton lock and condition variable multiple acquire and wait/notify
 Done Test 7
-Start Test 8: fast lock and condition variable 3 wait/notify all
+Start Test 8: owner lock and condition variable multiple acquire and wait/notify
 Done Test 8
-Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify
+Start Test 9: no lock condition variable wait/notify
 Done Test 9
-Start Test 10: owner lock and condition variable multiple acquire and wait/notify
+Start Test 10: locked condition variable wait/notify with front()
 Done Test 10
-Start Test 11: no lock condition variable wait/notify
-Done Test 11
-Start Test 12: locked condition variable wait/notify with front()
-Done Test 12
Index: sts/unified_locking/fast.cfa
===================================================================
--- tests/unified_locking/fast.cfa	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ 	(revision )
@@ -1,65 +1,0 @@
-#include <fstream.hfa>
-#include <locks.hfa>
-#include <thread.hfa>
-
-const unsigned int num_times = 50;
-
-struct MutexObj {
-	fast_lock l;
-	$thread * id;
-	size_t sum;
-};
-
-MutexObj mo;
-
-void trash() {
-	unsigned t[100];
-	for(i; 100) {
-		t[i] = 0xDEADBEEF;
-	}
-}
-
-unsigned cs() {
-	$thread * me = active_thread();
-	unsigned value = (unsigned)me;
-	lock(mo.l);
-	{
-		size_t tsum = mo.sum;
-		mo.id = me;
-		yield(random(5));
-		if(mo.id != me) sout | "Intruder!";
-		mo.sum = tsum + value;
-	}
-	unlock(mo.l);
-	return value;
-}
-
-thread LockCheck {
-	size_t sum;
-};
-
-void main(LockCheck & this) {
-	this.sum = 0;
-	for(num_times) {
-		trash();
-		this.sum += cs();
-		trash();
-		yield(random(10));
-	}
-}
-
-int main() {
-	size_t sum = -32;
-	mo.sum = -32;
-	processor p[2];
-	sout | "Starting";
-	{
-		LockCheck checkers[13];
-		for(i;13) {
-			sum += join(checkers[i]).sum;
-		}
-	}
-	sout | "Done!";
-	if(sum == mo.sum) sout | "Match!";
-	else sout | "No Match!" | sum | "vs" | mo.sum;
-}
Index: tests/unified_locking/locks.cfa
===================================================================
--- tests/unified_locking/locks.cfa	(revision c60ef6393bd5fd317ae2194ba30fb3a1d34b4678)
+++ tests/unified_locking/locks.cfa	(revision ca33b152dd74088cc759233fe5fe756db0550bf5)
@@ -15,7 +15,4 @@
 condition_variable( owner_lock ) c_o;
 
-fast_lock f;
-condition_variable( fast_lock ) c_f;
-
 thread T_C_M_WS1 {};
 
@@ -71,32 +68,4 @@
 		}
 		unlock(s);
-	}
-}
-
-thread T_C_F_WS1 {};
-
-void main( T_C_F_WS1 & this ) {
-	for (unsigned int i = 0; i < num_times; i++) {
-		lock(f);
-		if(empty(c_f) && i != num_times - 1) {
-			wait(c_f,f);
-		}else{
-			notify_one(c_f);
-		}
-		unlock(f);
-	}
-}
-
-thread T_C_F_WB1 {};
-
-void main( T_C_F_WB1 & this ) {
-	for (unsigned int i = 0; i < num_times; i++) {
-		lock(f);
-		if(counter(c_f) == 3 || i == num_times - 1) {
-			notify_all(c_f);
-		}else{
-			wait(c_f,f);
-		}
-		unlock(f);
 	}
 }
@@ -286,40 +255,28 @@
 	printf("Done Test 6\n");
 
-	printf("Start Test 7: fast lock and condition variable single wait/notify\n");
-	{
-		T_C_F_WS1 t1[2];
+	printf("Start Test 7: multi acquisiton lock and condition variable multiple acquire and wait/notify\n");
+	{
+		T_C_M_WS2 t1[2];
 	}
 	printf("Done Test 7\n");
 
-	printf("Start Test 8: fast lock and condition variable 3 wait/notify all\n");
-	{
-		T_C_F_WB1 t1[4];
+	printf("Start Test 8: owner lock and condition variable multiple acquire and wait/notify\n");
+	{
+		T_C_O_WS2 t1[2];
 	}
 	printf("Done Test 8\n");
 
-	printf("Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify\n");
-	{
-		T_C_M_WS2 t1[2];
-	}
-	printf("Done Test 9\n");
-
-	printf("Start Test 10: owner lock and condition variable multiple acquire and wait/notify\n");
-	{
-		T_C_O_WS2 t1[2];
-	}
-	printf("Done Test 10\n");
-
-	printf("Start Test 11: no lock condition variable wait/notify\n");
+	printf("Start Test 9: no lock condition variable wait/notify\n");
 	{
 		T_C_NLW t1;
 		T_C_NLS t2;
 	}
-	printf("Done Test 11\n");
-
-	printf("Start Test 12: locked condition variable wait/notify with front()\n");
+	printf("Done Test 9\n");
+
+	printf("Start Test 10: locked condition variable wait/notify with front()\n");
 	{
 		T_C_S_WNF t1[2];
 	}
-	printf("Done Test 12\n");
+	printf("Done Test 10\n");
 
 	// removed to limit test duration. Full test is in long run tests
