Index: libcfa/src/concurrency/locks.cfa
===================================================================
--- libcfa/src/concurrency/locks.cfa	(revision 41cde266bdf2b7a6f6039601707632f914d05a63)
+++ libcfa/src/concurrency/locks.cfa	(revision 089b1a9aa115169259c038079fecfcade7c26242)
@@ -17,5 +17,4 @@
 		this.t = t;
 		this.lock = 0p;
-		this.listed = false;
 	}
 
@@ -25,5 +24,4 @@
 		this.info = info;
 		this.lock = 0p;
-		this.listed = false;
 	}
 
@@ -36,8 +34,4 @@
 	info_thread(L) *& Next( info_thread(L) * this ) {
 		return (info_thread(L) *)Next( (Colable *)this );
-	}
-
-	bool listed( info_thread(L) * this ) {
-		return Next( (Colable *)this ) != 0p;
 	}
 }
@@ -194,6 +188,6 @@
     	// This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
 	    lock( cond->lock __cfaabi_dbg_ctx2 );
-	    
-	    if ( i->listed ) {			// is thread on queue
+	    if ( listed(i) ) {			// is thread on queue
+	    	i->signalled = false;
 	    	cond->last_thread = i;		// REMOVE THIS AFTER DEBUG
 			remove( cond->blocked_threads, *i );		 //remove this thread O(1)
@@ -227,5 +221,5 @@
 	void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
 		if(&popped != 0p) {
-			popped.listed = false;
+			popped.signalled = true;
 			count--;
 			if (popped.lock) {
@@ -266,5 +260,4 @@
 		addTail( blocked_threads, *i );
 		count++;
-		i->listed = true;
 		size_t recursion_count = 0;
 		if (i->lock) {
@@ -308,22 +301,26 @@
 	}
 	
-	void wait( condition_variable(L) & this, Duration duration ) with(this) {
+	bool wait( condition_variable(L) & this, Duration duration ) with(this) {
 		info_thread( L ) i = { active_thread() };
 		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-	}
-
-	void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { 
+		return i.signalled;
+	}
+
+	bool wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { 
 		info_thread( L ) i = { active_thread(), info };
 		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-	}
-
-	void wait( condition_variable(L) & this, Time time ) with(this) {
+		return i.signalled;
+	}
+
+	bool wait( condition_variable(L) & this, Time time ) with(this) {
 		info_thread( L ) i = { active_thread() };
 		queue_info_thread_timeout(this, i, time);
-	}
-
-	void wait( condition_variable(L) & this, uintptr_t info, Time time ) with(this) {
+		return i.signalled;
+	}
+
+	bool wait( condition_variable(L) & this, uintptr_t info, Time time ) with(this) {
 		info_thread( L ) i = { active_thread(), info };
 		queue_info_thread_timeout(this, i, time);
+		return i.signalled;
 	}
 
@@ -340,26 +337,30 @@
 	}
 	
-	void wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
+	bool wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
 		info_thread(L) i = { active_thread() };
 		i.lock = &l;
 		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-	}
-	
-	void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
+		return i.signalled;
+	}
+	
+	bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
 		info_thread(L) i = { active_thread(), info };
 		i.lock = &l;
 		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-	}
-	
-	void wait( condition_variable(L) & this, L & l, Time time ) with(this) {
+		return i.signalled;
+	}
+	
+	bool wait( condition_variable(L) & this, L & l, Time time ) with(this) {
 		info_thread(L) i = { active_thread() };
 		i.lock = &l;
 		queue_info_thread_timeout(this, i, time );
-	}
-	
-	void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
+		return i.signalled;
+	}
+	
+	bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
 		info_thread(L) i = { active_thread(), info };
 		i.lock = &l;
 		queue_info_thread_timeout(this, i, time );
-	}
-}
+		return i.signalled;
+	}
+}
Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision 41cde266bdf2b7a6f6039601707632f914d05a63)
+++ libcfa/src/concurrency/locks.hfa	(revision 089b1a9aa115169259c038079fecfcade7c26242)
@@ -36,5 +36,5 @@
 		uintptr_t info;
 		L * lock;
-		bool listed;					// true if info_thread is on queue, false otherwise;
+		bool signalled;					// true when signalled and false when timeout wakes thread
 	};
 
@@ -46,5 +46,4 @@
 	info_thread(L) *& Back( info_thread(L) * this );
 	info_thread(L) *& Next( info_thread(L) * this );
-	bool listed( info_thread(L) * this );
 }
 
@@ -52,14 +51,4 @@
 //// Blocking Locks
 ///////////////////////////////////////////////////////////////////
-
-// struct lock_thread {
-// 	struct $thread * t;
-// 	lock_thread * next;
-// };
-
-// void ?{}( lock_thread & this, struct $thread * thd );
-// void ^?{}( lock_thread & this );
-
-// lock_thread *& get_next( lock_thread & );
 
 struct blocking_lock {
@@ -183,17 +172,16 @@
 	int counter( condition_variable(L) & this );
 
-	// TODO: look into changing timout routines to return bool showing if signalled or woken by kernel
 	void wait( condition_variable(L) & this );
 	void wait( condition_variable(L) & this, uintptr_t info );
-	void wait( condition_variable(L) & this, Duration duration );
-	void wait( condition_variable(L) & this, uintptr_t info, Duration duration );
-	void wait( condition_variable(L) & this, Time time );
-	void wait( condition_variable(L) & this, uintptr_t info, Time time );
+	bool wait( condition_variable(L) & this, Duration duration );
+	bool wait( condition_variable(L) & this, uintptr_t info, Duration duration );
+	bool wait( condition_variable(L) & this, Time time );
+	bool wait( condition_variable(L) & this, uintptr_t info, Time time );
 
 	void wait( condition_variable(L) & this, L & l );
 	void wait( condition_variable(L) & this, L & l, uintptr_t info );
-	void wait( condition_variable(L) & this, L & l, Duration duration );
-	void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
-	void wait( condition_variable(L) & this, L & l, Time time );
-	void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
+	bool wait( condition_variable(L) & this, L & l, Duration duration );
+	bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
+	bool wait( condition_variable(L) & this, L & l, Time time );
+	bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
 }
Index: tests/locks.cfa
===================================================================
--- tests/locks.cfa	(revision 41cde266bdf2b7a6f6039601707632f914d05a63)
+++ tests/locks.cfa	(revision 089b1a9aa115169259c038079fecfcade7c26242)
@@ -1,9 +1,4 @@
 #include <stdio.h>
 #include "locks.hfa"
-
-#include "kernel_private.hfa"
-#include <stdlib.h>
-
-#include <kernel.hfa>
 #include <stdlib.hfa>
 #include <thread.hfa>
@@ -224,4 +219,5 @@
 int main() {
 	processor p[2];
+	wait( c_s, 1`ns );
 	printf("Start Test 1: multi acquisition lock and condition variable single wait/notify\n");
 	{
Index: tests/timeout_lock.cfa
===================================================================
--- tests/timeout_lock.cfa	(revision 089b1a9aa115169259c038079fecfcade7c26242)
+++ tests/timeout_lock.cfa	(revision 089b1a9aa115169259c038079fecfcade7c26242)
@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include "locks.hfa"
+#include "alarm.hfa"
+#include <stdlib.hfa>
+#include <thread.hfa>
+#include "kernel.cfa"
+
+multiple_acquisition_lock m;
+condition_variable( multiple_acquisition_lock ) c_m;
+
+semaphore s; // used for barrier like behaviour
+
+const unsigned int NoOfTimes = 20;
+
+void block() {
+	if (s.count == 0) {
+		P(s);
+	} else {
+		V(s);
+	}
+}
+
+thread T1 {};
+
+void main( T1 & this ) {
+	lock(m);
+	wait( c_m, m, 1`s );
+	printf("Thread: %p timedout\n", active_thread());
+
+	block();
+
+	// Test calls which occur increasingly close to timeout value.
+
+	for ( unsigned int i = 0; i < NoOfTimes + 3; i += 1 ) {
+	    if ( wait( c_m, m, 1`s ) ) { 
+			printf("Thread: %p signalled\n", active_thread());
+	    } else {
+			printf("Thread: %p timedout\n", active_thread());
+	    } // if
+
+	    block();
+	} // for
+}
+
+
+thread T2 {};
+
+void main( T2 & this ) {
+	block();
+
+	// Test calls which occur increasingly close to timeout value.
+
+	sleep( 100000000`ns );
+	notify_one(c_m);
+	block();
+
+	sleep( 500000000`ns );
+	notify_one(c_m);
+	block();
+
+	sleep( 900000000`ns );
+	notify_one(c_m);
+	block();
+
+	for ( unsigned int i = 0; i < NoOfTimes; i += 1 ) {
+	    sleep( 999700000`ns );
+		notify_one(c_m);
+	    block();
+	} // for
+}
+
+int main() {
+	processor p[2];
+	printf("Start Test 1: surface testing condition variable timeout routines\n");
+	wait( c_m, 1`ns );														// bool wait( condition_variable(L) & this, Duration duration );	
+	wait( c_m, 10, 1`ns );													// bool wait( condition_variable(L) & this, uintptr_t info, Duration duration );
+	wait( c_m, __kernel_get_time() + 1`ns );								// bool wait( condition_variable(L) & this, Time time );
+	wait( c_m, 10, __kernel_get_time() + 1`ns );							// bool wait( condition_variable(L) & this, uintptr_t info, Time time );
+	lock(m); wait( c_m, m, 1`ns ); unlock(m); 								// bool wait( condition_variable(L) & this, L & l, Duration duration );
+	lock(m); wait( c_m, m, 10, 1`ns ); unlock(m);							// bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
+	lock(m); wait( c_m, m, __kernel_get_time() + 1`ns ); unlock(m);			// bool wait( condition_variable(L) & this, L & l, Time time );
+	lock(m); wait( c_m, m, 10, __kernel_get_time() + 1`ns ); unlock(m);		// bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
+	printf("Done Test 1\n");
+
+	printf("Start Test 2: testing timeout vs signalling with varying timeout durations\n");
+	s{ 0 };
+	{
+		T1 t1;
+		T2 t2;
+	}
+	printf("Done Test 2\n");
+}
