Index: tests/concurrent/signal/block.c
===================================================================
--- tests/concurrent/signal/block.c	(revision 200fcb3c496b08f843f691550554b21d786aad38)
+++ 	(revision )
@@ -1,139 +1,0 @@
-//---------------------------------------------------------
-// Barging test
-// Ensures that no barging can occur between :
-//   - the frontend of the signal_block and the signaled thread
-//   - the signaled  threadand the backend of the signal_block
-//---------------------------------------------------------
-
-
-#include <fstream.hfa>
-#include <kernel.hfa>
-#include <monitor.hfa>
-#include <stdlib.hfa>
-#include <thread.hfa>
-#include <time.hfa>
-
-#include "long_tests.hfa"
-
-#ifndef PREEMPTION_RATE
-#define PREEMPTION_RATE 10`ms
-#endif
-
-Duration default_preemption() {
-	return PREEMPTION_RATE;
-}
-
-#ifdef TEST_LONG
-static const unsigned long N = 150_000ul;
-#else
-static const unsigned long N = 5_000ul;
-#endif
-
-enum state_t { WAITED, SIGNAL, BARGE };
-
-monitor global_data_t {
-	thread_desc * last_thread;
-	thread_desc * last_signaller;
-};
-
-void ?{} ( global_data_t & this ) {
-	this.last_thread = NULL;
-	this.last_signaller = NULL;
-}
-
-void ^?{} ( global_data_t & mutex this ) {}
-
-global_data_t globalA, globalB;
-
-condition cond;
-
-volatile bool done;
-
-//------------------------------------------------------------------------------
-void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) {
-    wait( cond, (uintptr_t)active_thread() );
-
-	yield( random( 10 ) );
-
-	if(a.last_thread != a.last_signaller || b.last_thread != b.last_signaller ) {
-		sout | "ERROR Barging detected, expected" | a.last_signaller | b.last_signaller | "got" | a.last_thread | b.last_thread;
-		abort();
-	}
-
-	a.last_thread = b.last_thread = active_thread();
-
-	yield( random( 10 ) );
-}
-
-thread Waiter {};
-void main( Waiter & this ) {
-	for( int i = 0; TEST(i < N); i++ ) {
-		wait_op( globalA, globalB, i );
-		KICK_WATCHDOG;
-	}
-}
-
-//------------------------------------------------------------------------------
-void signal_op( global_data_t & mutex a, global_data_t & mutex b ) {
-	yield( random( 10 ) );
-
-	[a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = active_thread();
-
-	if( !is_empty( cond ) ) {
-
-		thread_desc * next = front( cond );
-
-		if( ! signal_block( cond ) ) {
-			sout | "ERROR expected to be able to signal";
-			abort();
-		}
-
-		yield( random( 10 ) );
-
-		if(a.last_thread != next || b.last_thread != next) {
-			sout | "ERROR Barging detected, expected" | next | "got" | a.last_thread | b.last_thread;
-			abort();
-		}
-	}
-
-}
-
-thread Signaller {};
-void main( Signaller & this ) {
-	while( !done ) {
-		signal_op( globalA, globalB );
-	}
-}
-
-//------------------------------------------------------------------------------
-void barge_op( global_data_t & mutex a ) {
-	a.last_thread = active_thread();
-}
-
-thread Barger {};
-void main( Barger & this ) {
-	for( unsigned i = 0; !done; i++ ) {
-		//Choose some monitor to barge into with some irregular pattern
-		bool choose_a = (i % 13) > (i % 17);
-		if ( choose_a ) barge_op( globalA );
-		else barge_op( globalB );
-	}
-}
-
-//------------------------------------------------------------------------------
-
-int main(int argc, char* argv[]) {
-	srandom( time( NULL ) );
-	done = false;
-	processor p;
-	{
-		Signaller s[4];
-		Barger b[13];
-		sout | "Starting waiters";
-		{
-			Waiter w[3];
-		}
-		sout | "Waiters done";
-		done = true;
-	}
-}
Index: tests/concurrent/signal/block.cfa
===================================================================
--- tests/concurrent/signal/block.cfa	(revision 9fb8f01d220653c3f0b46da4a12ae9e1302579b9)
+++ tests/concurrent/signal/block.cfa	(revision 9fb8f01d220653c3f0b46da4a12ae9e1302579b9)
@@ -0,0 +1,139 @@
+//---------------------------------------------------------
+// Barging test
+// Ensures that no barging can occur between :
+//   - the frontend of the signal_block and the signaled thread
+//   - the signaled  threadand the backend of the signal_block
+//---------------------------------------------------------
+
+
+#include <fstream.hfa>
+#include <kernel.hfa>
+#include <monitor.hfa>
+#include <stdlib.hfa>
+#include <thread.hfa>
+#include <time.hfa>
+
+#include "long_tests.hfa"
+
+#ifndef PREEMPTION_RATE
+#define PREEMPTION_RATE 10`ms
+#endif
+
+Duration default_preemption() {
+	return PREEMPTION_RATE;
+}
+
+#ifdef TEST_LONG
+static const unsigned long N = 150_000ul;
+#else
+static const unsigned long N = 5_000ul;
+#endif
+
+enum state_t { WAITED, SIGNAL, BARGE };
+
+monitor global_data_t {
+	thread_desc * last_thread;
+	thread_desc * last_signaller;
+};
+
+void ?{} ( global_data_t & this ) {
+	this.last_thread = NULL;
+	this.last_signaller = NULL;
+}
+
+void ^?{} ( global_data_t & mutex this ) {}
+
+global_data_t globalA, globalB;
+
+condition cond;
+
+volatile bool done;
+
+//------------------------------------------------------------------------------
+void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) {
+    wait( cond, (uintptr_t)active_thread() );
+
+	yield( random( 10 ) );
+
+	if(a.last_thread != a.last_signaller || b.last_thread != b.last_signaller ) {
+		sout | "ERROR Barging detected, expected" | a.last_signaller | b.last_signaller | "got" | a.last_thread | b.last_thread;
+		abort();
+	}
+
+	a.last_thread = b.last_thread = active_thread();
+
+	yield( random( 10 ) );
+}
+
+thread Waiter {};
+void main( Waiter & this ) {
+	for( int i = 0; TEST(i < N); i++ ) {
+		wait_op( globalA, globalB, i );
+		KICK_WATCHDOG;
+	}
+}
+
+//------------------------------------------------------------------------------
+void signal_op( global_data_t & mutex a, global_data_t & mutex b ) {
+	yield( random( 10 ) );
+
+	[a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = active_thread();
+
+	if( !is_empty( cond ) ) {
+
+		thread_desc * next = front( cond );
+
+		if( ! signal_block( cond ) ) {
+			sout | "ERROR expected to be able to signal";
+			abort();
+		}
+
+		yield( random( 10 ) );
+
+		if(a.last_thread != next || b.last_thread != next) {
+			sout | "ERROR Barging detected, expected" | next | "got" | a.last_thread | b.last_thread;
+			abort();
+		}
+	}
+
+}
+
+thread Signaller {};
+void main( Signaller & this ) {
+	while( !done ) {
+		signal_op( globalA, globalB );
+	}
+}
+
+//------------------------------------------------------------------------------
+void barge_op( global_data_t & mutex a ) {
+	a.last_thread = active_thread();
+}
+
+thread Barger {};
+void main( Barger & this ) {
+	for( unsigned i = 0; !done; i++ ) {
+		//Choose some monitor to barge into with some irregular pattern
+		bool choose_a = (i % 13) > (i % 17);
+		if ( choose_a ) barge_op( globalA );
+		else barge_op( globalB );
+	}
+}
+
+//------------------------------------------------------------------------------
+
+int main(int argc, char* argv[]) {
+	srandom( time( NULL ) );
+	done = false;
+	processor p;
+	{
+		Signaller s[4];
+		Barger b[13];
+		sout | "Starting waiters";
+		{
+			Waiter w[3];
+		}
+		sout | "Waiters done";
+		done = true;
+	}
+}
Index: tests/concurrent/signal/disjoint.c
===================================================================
--- tests/concurrent/signal/disjoint.c	(revision 200fcb3c496b08f843f691550554b21d786aad38)
+++ 	(revision )
@@ -1,129 +1,0 @@
-#include <fstream.hfa>
-#include <kernel.hfa>
-#include <monitor.hfa>
-#include <thread.hfa>
-#include <time.hfa>
-
-#include "long_tests.hfa"
-
-#ifndef PREEMPTION_RATE
-#define PREEMPTION_RATE 10`ms
-#endif
-
-Duration default_preemption() {
-	return PREEMPTION_RATE;
-}
-
-#ifdef TEST_LONG
-static const unsigned long N = 300_000ul;
-#else
-static const unsigned long N = 10_000ul;
-#endif
-
-enum state_t { WAIT, SIGNAL, BARGE };
-
-monitor global_t {};
-global_t mut;
-
-monitor global_data_t;
-void ?{}( global_data_t & this );
-void ^?{} ( global_data_t & mutex this );
-
-monitor global_data_t {
-	int counter;
-	state_t state;
-} data;
-
-condition cond;
-
-volatile bool all_done;
-
-void ?{}( global_data_t & this ) {
-	this.counter == 0;
-	this.state = BARGE;
-}
-
-void ^?{} ( global_data_t & mutex this ) {}
-
-//------------------------------------------------------------------------------
-// Barging logic
-void barge( global_data_t & mutex d ) {
-	d.state = BARGE;
-}
-
-thread Barger {};
-
-void main( Barger & this ) {
-	while( !all_done ) {
-		barge( data );
-		yield();
-	}
-}
-
-//------------------------------------------------------------------------------
-// Waiting logic
-bool wait( global_t & mutex m, global_data_t & mutex d ) {
-	wait( cond );
-	if( d.state != SIGNAL ) {
-		sout | "ERROR barging!";
-	}
-
-	#if !defined(TEST_FOREVER)
-		d.counter++;
-		if( (d.counter % 1000) == 0 ) sout | d.counter;
-	#endif
-
-	return TEST(d.counter < N);
-}
-
-thread Waiter {};
-
-void main( Waiter & this ) {
-	while( wait( mut, data ) ) { KICK_WATCHDOG; yield(); }
-}
-
-
-//------------------------------------------------------------------------------
-// Signalling logic
-void signal( condition & cond, global_t & mutex a, global_data_t & mutex b ) {
-	b.state = SIGNAL;
-	signal( cond );
-}
-
-void logic( global_t & mutex a ) {
-	signal( cond, a, data );
-
-	yield( random( 10 ) );
-
-	//This is technically a mutual exclusion violation but the mutex monitor protects us
-	bool running = TEST(data.counter < N) && data.counter > 0;
-	if( data.state != SIGNAL && running ) {
-		sout | "ERROR Eager signal" | data.state;
-	}
-}
-
-thread Signaller {};
-
-void main( Signaller & this ) {
-	while( !all_done ) {
-		logic( mut );
-		yield();
-	}
-}
-
-//------------------------------------------------------------------------------
-// Main loop
-int main(int argc, char* argv[]) {
-	srandom( time( NULL ) );
-	all_done = false;
-	processor p;
-	{
-		Signaller s;
-		Barger b[17];
-		{
-			Waiter w[4];
-		}
-		sout | "All waiter done";
-		all_done = true;
-	}
-}
Index: tests/concurrent/signal/disjoint.cfa
===================================================================
--- tests/concurrent/signal/disjoint.cfa	(revision 9fb8f01d220653c3f0b46da4a12ae9e1302579b9)
+++ tests/concurrent/signal/disjoint.cfa	(revision 9fb8f01d220653c3f0b46da4a12ae9e1302579b9)
@@ -0,0 +1,129 @@
+#include <fstream.hfa>
+#include <kernel.hfa>
+#include <monitor.hfa>
+#include <thread.hfa>
+#include <time.hfa>
+
+#include "long_tests.hfa"
+
+#ifndef PREEMPTION_RATE
+#define PREEMPTION_RATE 10`ms
+#endif
+
+Duration default_preemption() {
+	return PREEMPTION_RATE;
+}
+
+#ifdef TEST_LONG
+static const unsigned long N = 300_000ul;
+#else
+static const unsigned long N = 10_000ul;
+#endif
+
+enum state_t { WAIT, SIGNAL, BARGE };
+
+monitor global_t {};
+global_t mut;
+
+monitor global_data_t;
+void ?{}( global_data_t & this );
+void ^?{} ( global_data_t & mutex this );
+
+monitor global_data_t {
+	int counter;
+	state_t state;
+} data;
+
+condition cond;
+
+volatile bool all_done;
+
+void ?{}( global_data_t & this ) {
+	this.counter == 0;
+	this.state = BARGE;
+}
+
+void ^?{} ( global_data_t & mutex this ) {}
+
+//------------------------------------------------------------------------------
+// Barging logic
+void barge( global_data_t & mutex d ) {
+	d.state = BARGE;
+}
+
+thread Barger {};
+
+void main( Barger & this ) {
+	while( !all_done ) {
+		barge( data );
+		yield();
+	}
+}
+
+//------------------------------------------------------------------------------
+// Waiting logic
+bool wait( global_t & mutex m, global_data_t & mutex d ) {
+	wait( cond );
+	if( d.state != SIGNAL ) {
+		sout | "ERROR barging!";
+	}
+
+	#if !defined(TEST_FOREVER)
+		d.counter++;
+		if( (d.counter % 1000) == 0 ) sout | d.counter;
+	#endif
+
+	return TEST(d.counter < N);
+}
+
+thread Waiter {};
+
+void main( Waiter & this ) {
+	while( wait( mut, data ) ) { KICK_WATCHDOG; yield(); }
+}
+
+
+//------------------------------------------------------------------------------
+// Signalling logic
+void signal( condition & cond, global_t & mutex a, global_data_t & mutex b ) {
+	b.state = SIGNAL;
+	signal( cond );
+}
+
+void logic( global_t & mutex a ) {
+	signal( cond, a, data );
+
+	yield( random( 10 ) );
+
+	//This is technically a mutual exclusion violation but the mutex monitor protects us
+	bool running = TEST(data.counter < N) && data.counter > 0;
+	if( data.state != SIGNAL && running ) {
+		sout | "ERROR Eager signal" | data.state;
+	}
+}
+
+thread Signaller {};
+
+void main( Signaller & this ) {
+	while( !all_done ) {
+		logic( mut );
+		yield();
+	}
+}
+
+//------------------------------------------------------------------------------
+// Main loop
+int main(int argc, char* argv[]) {
+	srandom( time( NULL ) );
+	all_done = false;
+	processor p;
+	{
+		Signaller s;
+		Barger b[17];
+		{
+			Waiter w[4];
+		}
+		sout | "All waiter done";
+		all_done = true;
+	}
+}
Index: tests/concurrent/signal/wait.c
===================================================================
--- tests/concurrent/signal/wait.c	(revision 200fcb3c496b08f843f691550554b21d786aad38)
+++ 	(revision )
@@ -1,153 +1,0 @@
-//---------------------------------------------------------
-// Multi wait test
-// Ensures that no deadlock from waiting/signalling conditions
-//---------------------------------------------------------
-
-
-#include <fstream.hfa>
-#include <kernel.hfa>
-#include <monitor.hfa>
-#include <stdlib.hfa>
-#include <thread.hfa>
-#include <time.hfa>
-
-#define __kick_rate 12000ul
-#include "long_tests.hfa"
-
-#ifndef PREEMPTION_RATE
-#define PREEMPTION_RATE 10`ms
-#endif
-
-Duration default_preemption() {
-	return PREEMPTION_RATE;
-}
-
-#ifdef TEST_LONG
-static const unsigned long N = 375_000ul;
-#else
-static const unsigned long N = 2_500ul;
-#endif
-
-monitor global_t {};
-
-global_t globalA;
-global_t globalB;
-global_t globalC;
-
-condition condAB, condAC, condBC, condABC;
-
-thread Signaler {};
-thread WaiterAB {};
-thread WaiterAC {};
-thread WaiterBC {};
-thread WaiterABC{};
-
-volatile int waiter_left;
-
-//----------------------------------------------------------------------------------------------------
-// Tools
-void signal( condition & cond, global_t & mutex a, global_t & mutex b ) {
-	signal( cond );
-}
-
-void signal( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
-	signal( cond );
-}
-
-void wait( condition & cond, global_t & mutex a, global_t & mutex b ) {
-	wait( cond );
-}
-
-void wait( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
-	wait( cond );
-}
-
-//----------------------------------------------------------------------------------------------------
-// Signaler
-void main( Signaler & this ) {
-
-	while( waiter_left != 0 ) {
-		unsigned action = random( 4 );
-		switch( action ) {
-			case 0:
-				signal( condABC, globalA, globalB, globalC );
-				break;
-			case 1:
-				signal( condAB , globalA, globalB );
-				break;
-			case 2:
-				signal( condBC , globalB, globalC );
-				break;
-			case 3:
-				signal( condAC , globalA, globalC );
-				break;
-			default:
-				sout | "Something went wrong";
-				abort();
-		}
-		yield();
-	}
-}
-
-//----------------------------------------------------------------------------------------------------
-// Waiter ABC
-void main( WaiterABC & this ) {
-	for( int i = 0; TEST(i < N); i++ ) {
-		wait( condABC, globalA, globalB, globalC );
-		KICK_WATCHDOG;
-	}
-
-	__sync_fetch_and_sub_4( &waiter_left, 1);
-}
-
-//----------------------------------------------------------------------------------------------------
-// Waiter AB
-void main( WaiterAB & this ) {
-	for( int i = 0; TEST(i < N); i++ ) {
-		wait( condAB , globalA, globalB );
-		KICK_WATCHDOG;
-	}
-
-	__sync_fetch_and_sub_4( &waiter_left, 1);
-}
-
-//----------------------------------------------------------------------------------------------------
-// Waiter AC
-void main( WaiterAC & this ) {
-	for( int i = 0; TEST(i < N); i++ ) {
-		wait( condAC , globalA, globalC );
-		KICK_WATCHDOG;
-	}
-
-	__sync_fetch_and_sub_4( &waiter_left, 1);
-}
-
-//----------------------------------------------------------------------------------------------------
-// Waiter BC
-void main( WaiterBC & this ) {
-	for( int i = 0; TEST(i < N); i++ ) {
-		wait( condBC , globalB, globalC );
-		KICK_WATCHDOG;
-	}
-
-	__sync_fetch_and_sub_4( &waiter_left, 1);
-}
-
-//----------------------------------------------------------------------------------------------------
-// Main
-int main(int argc, char* argv[]) {
-	srandom( time( NULL ) );
-	waiter_left = 4;
-	processor p[2];
-	sout | "Starting";
-	{
-		Signaler  e;
-		{
-			WaiterABC a;
-			WaiterAB  b;
-			WaiterBC  c;
-			WaiterAC  d;
-		}
-	}
-	sout | "Done";
-}
Index: tests/concurrent/signal/wait.cfa
===================================================================
--- tests/concurrent/signal/wait.cfa	(revision 9fb8f01d220653c3f0b46da4a12ae9e1302579b9)
+++ tests/concurrent/signal/wait.cfa	(revision 9fb8f01d220653c3f0b46da4a12ae9e1302579b9)
@@ -0,0 +1,153 @@
+//---------------------------------------------------------
+// Multi wait test
+// Ensures that no deadlock from waiting/signalling conditions
+//---------------------------------------------------------
+
+
+#include <fstream.hfa>
+#include <kernel.hfa>
+#include <monitor.hfa>
+#include <stdlib.hfa>
+#include <thread.hfa>
+#include <time.hfa>
+
+#define __kick_rate 12000ul
+#include "long_tests.hfa"
+
+#ifndef PREEMPTION_RATE
+#define PREEMPTION_RATE 10`ms
+#endif
+
+Duration default_preemption() {
+	return PREEMPTION_RATE;
+}
+
+#ifdef TEST_LONG
+static const unsigned long N = 375_000ul;
+#else
+static const unsigned long N = 2_500ul;
+#endif
+
+monitor global_t {};
+
+global_t globalA;
+global_t globalB;
+global_t globalC;
+
+condition condAB, condAC, condBC, condABC;
+
+thread Signaler {};
+thread WaiterAB {};
+thread WaiterAC {};
+thread WaiterBC {};
+thread WaiterABC{};
+
+volatile int waiter_left;
+
+//----------------------------------------------------------------------------------------------------
+// Tools
+void signal( condition & cond, global_t & mutex a, global_t & mutex b ) {
+	signal( cond );
+}
+
+void signal( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
+	signal( cond );
+}
+
+void wait( condition & cond, global_t & mutex a, global_t & mutex b ) {
+	wait( cond );
+}
+
+void wait( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
+	wait( cond );
+}
+
+//----------------------------------------------------------------------------------------------------
+// Signaler
+void main( Signaler & this ) {
+
+	while( waiter_left != 0 ) {
+		unsigned action = random( 4 );
+		switch( action ) {
+			case 0:
+				signal( condABC, globalA, globalB, globalC );
+				break;
+			case 1:
+				signal( condAB , globalA, globalB );
+				break;
+			case 2:
+				signal( condBC , globalB, globalC );
+				break;
+			case 3:
+				signal( condAC , globalA, globalC );
+				break;
+			default:
+				sout | "Something went wrong";
+				abort();
+		}
+		yield();
+	}
+}
+
+//----------------------------------------------------------------------------------------------------
+// Waiter ABC
+void main( WaiterABC & this ) {
+	for( int i = 0; TEST(i < N); i++ ) {
+		wait( condABC, globalA, globalB, globalC );
+		KICK_WATCHDOG;
+	}
+
+	__sync_fetch_and_sub_4( &waiter_left, 1);
+}
+
+//----------------------------------------------------------------------------------------------------
+// Waiter AB
+void main( WaiterAB & this ) {
+	for( int i = 0; TEST(i < N); i++ ) {
+		wait( condAB , globalA, globalB );
+		KICK_WATCHDOG;
+	}
+
+	__sync_fetch_and_sub_4( &waiter_left, 1);
+}
+
+//----------------------------------------------------------------------------------------------------
+// Waiter AC
+void main( WaiterAC & this ) {
+	for( int i = 0; TEST(i < N); i++ ) {
+		wait( condAC , globalA, globalC );
+		KICK_WATCHDOG;
+	}
+
+	__sync_fetch_and_sub_4( &waiter_left, 1);
+}
+
+//----------------------------------------------------------------------------------------------------
+// Waiter BC
+void main( WaiterBC & this ) {
+	for( int i = 0; TEST(i < N); i++ ) {
+		wait( condBC , globalB, globalC );
+		KICK_WATCHDOG;
+	}
+
+	__sync_fetch_and_sub_4( &waiter_left, 1);
+}
+
+//----------------------------------------------------------------------------------------------------
+// Main
+int main(int argc, char* argv[]) {
+	srandom( time( NULL ) );
+	waiter_left = 4;
+	processor p[2];
+	sout | "Starting";
+	{
+		Signaler  e;
+		{
+			WaiterABC a;
+			WaiterAB  b;
+			WaiterBC  c;
+			WaiterAC  d;
+		}
+	}
+	sout | "Done";
+}
