Index: tests/concurrent/actors/.expect/dynamic.txt
===================================================================
--- tests/concurrent/actors/.expect/dynamic.txt	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
+++ tests/concurrent/actors/.expect/dynamic.txt	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
@@ -0,0 +1,5 @@
+starting
+started
+stopping
+Done
+stopped
Index: tests/concurrent/actors/.expect/executor.txt
===================================================================
--- tests/concurrent/actors/.expect/executor.txt	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
+++ tests/concurrent/actors/.expect/executor.txt	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
@@ -0,0 +1,4 @@
+starting
+started
+stopping
+stopped
Index: tests/concurrent/actors/.expect/static.txt
===================================================================
--- tests/concurrent/actors/.expect/static.txt	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
+++ tests/concurrent/actors/.expect/static.txt	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
@@ -0,0 +1,5 @@
+starting
+started
+stopping
+Done
+stopped
Index: tests/concurrent/actors/dynamic.cfa
===================================================================
--- tests/concurrent/actors/dynamic.cfa	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
+++ tests/concurrent/actors/dynamic.cfa	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
@@ -0,0 +1,74 @@
+#include <actor.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>
+#include <string.h>
+#include <stdio.h>
+
+int Times = 1000000;								// default values
+
+struct derived_actor {
+    inline actor;
+};
+void ?{}( derived_actor & this ) { ((actor &)this){}; }
+
+struct derived_msg {
+    inline message;
+    int cnt;
+};
+
+void ?{}( derived_msg & this, int cnt ) {
+    ((message &) this){ Delete };
+    this.cnt = cnt;
+}
+void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; }
+
+
+Allocation receive( derived_actor & receiver, derived_msg & msg ) {
+    if ( msg.cnt >= Times ) {
+        sout | "Done";
+        return Delete;
+    }
+    derived_msg * d_msg = alloc();
+    (*d_msg){ msg.cnt + 1 };
+    derived_actor * d_actor = alloc();
+    (*d_actor){};
+    *d_actor | *d_msg;
+    return Delete;
+}
+
+int main( int argc, char * argv[] ) {
+    switch ( argc ) {
+	  case 2:
+		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
+			Times = atoi( argv[1] );
+			if ( Times < 1 ) goto Usage;
+		} // if
+	  case 1:											// use defaults
+		break;
+	  default:
+	  Usage:
+		sout | "Usage: " | argv[0] | " [ times (> 0) ]";
+		exit( EXIT_FAILURE );
+	} // switch
+
+    printf("starting\n");
+
+    executor e{ 0, 1, 1, false };
+    start_actor_system( e );
+
+    printf("started\n");
+
+    derived_msg * d_msg = alloc();
+    (*d_msg){};
+    derived_actor * d_actor = alloc();
+    (*d_actor){};
+    *d_actor | *d_msg;
+
+    printf("stopping\n");
+
+    stop_actor_system();
+
+    printf("stopped\n");
+
+    return 0;
+}
Index: tests/concurrent/actors/executor.cfa
===================================================================
--- tests/concurrent/actors/executor.cfa	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
+++ tests/concurrent/actors/executor.cfa	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
@@ -0,0 +1,109 @@
+#include <actor.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>
+#include <string.h>
+#include <stdio.h>
+
+// int Actors = 40000, Set = 100, Rounds = 100, Processors = 1, Batch = 1, BufSize = 10; // default values
+int Actors = 1000, Set = 20, Rounds = 10, Processors = 1, Batch = 1, BufSize = 10; // other defaults for test to run in reasonable time
+
+static int ids = 0;
+struct d_actor { 
+    inline actor;
+    d_actor * gstart;
+    int id, rounds, recs, sends;
+};
+void ?{}( d_actor & this ) with(this) {
+    ((actor &)this){};
+    id = ids++;
+    gstart = (&this + (id / Set * Set - id)); // remember group-start array-element
+    rounds = Set * Rounds;	// send at least one message to each group member
+    recs = 0;
+    sends = 0;
+}
+
+struct d_msg { inline message; } shared_msg;
+void ?{}( d_msg & this ) { ((message &) this){ Nodelete }; }
+
+Allocation receive( d_actor & this, d_msg & msg ) with( this ) {
+    if ( recs == rounds ) return Finished;
+    if ( recs % Batch == 0 ) {
+        for ( i; Batch ) {
+            gstart[sends % Set] | shared_msg;
+            sends += 1;
+        }
+    }
+    recs += 1;
+    return Nodelete;
+}
+
+int main( int argc, char * argv[] ) {
+    switch ( argc ) {
+	  case 7:
+		if ( strcmp( argv[6], "d" ) != 0 ) {			// default ?
+			BufSize = atoi( argv[6] );
+			if ( BufSize < 0 ) goto Usage;
+		} // if
+	  case 6:
+		if ( strcmp( argv[5], "d" ) != 0 ) {			// default ?
+			Batch = atoi( argv[5] );
+			if ( Batch < 1 ) goto Usage;
+		} // if
+	  case 5:
+		if ( strcmp( argv[4], "d" ) != 0 ) {			// default ?
+			Processors = atoi( argv[4] );
+			if ( Processors < 1 ) goto Usage;
+		} // if
+	  case 4:
+		if ( strcmp( argv[3], "d" ) != 0 ) {			// default ?
+			Rounds = atoi( argv[3] );
+			if ( Rounds < 1 ) goto Usage;
+		} // if
+	  case 3:
+		if ( strcmp( argv[2], "d" ) != 0 ) {			// default ?
+			Set = atoi( argv[2] );
+			if ( Set < 1 ) goto Usage;
+		} // if
+	  case 2:
+		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
+			Actors = atoi( argv[1] );
+			if ( Actors < 1 || Actors <= Set || Actors % Set != 0 ) goto Usage;
+		} // if
+	  case 1:											// use defaults
+		break;
+	  default:
+	  Usage:
+		sout | "Usage: " | argv[0]
+             | " [ actors (> 0 && > set && actors % set == 0 ) | 'd' (default " | Actors
+			 | ") ] [ set (> 0) | 'd' (default " | Set
+			 | ") ] [ rounds (> 0) | 'd' (default " | Rounds
+			 | ") ] [ processors (> 0) | 'd' (default " | Processors
+			 | ") ] [ batch (> 0) | 'd' (default " | Batch
+			 | ") ] [ buffer size (>= 0) | 'd' (default " | BufSize
+			 | ") ]" ;
+		exit( EXIT_FAILURE );
+	} // switch
+
+    
+    executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 512, true };
+
+    printf("starting\n");
+
+    start_actor_system( e );
+
+    printf("started\n");
+
+    d_actor actors[ Actors ];
+
+	for ( i; Actors ) {
+		actors[i] | shared_msg;
+	} // for
+
+    printf("stopping\n");
+
+    stop_actor_system();
+
+    printf("stopped\n");
+
+    return 0;
+}
Index: tests/concurrent/actors/matrix.cfa
===================================================================
--- tests/concurrent/actors/matrix.cfa	(revision 8a972486173f920eea1f1868fff138e1568a8a59)
+++ tests/concurrent/actors/matrix.cfa	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
@@ -5,5 +5,5 @@
 #include <stdio.h>
 
-unsigned int xr = 100, xc = 100, yc = 100, Processors = 1; // default values
+unsigned int xr = 500, xc = 500, yc = 500, Processors = 1; // default values
 
 struct derived_actor {
Index: tests/concurrent/actors/static.cfa
===================================================================
--- tests/concurrent/actors/static.cfa	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
+++ tests/concurrent/actors/static.cfa	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
@@ -0,0 +1,71 @@
+#include <actor.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>
+#include <string.h>
+#include <stdio.h>
+
+int Times = 1000000;								// default values
+
+struct derived_actor {
+    inline actor;
+};
+void ?{}( derived_actor & this ) { ((actor &)this){}; }
+
+struct derived_msg {
+    inline message;
+    int cnt;
+};
+
+void ?{}( derived_msg & this, int cnt ) {
+    ((message &) this){ Nodelete };
+    this.cnt = cnt;
+}
+void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; }
+
+
+Allocation receive( derived_actor & receiver, derived_msg & msg ) {
+    if ( msg.cnt >= Times ) {
+        sout | "Done";
+        return Finished;
+    }
+    msg.cnt++;
+    receiver | msg;
+    return Nodelete;
+}
+
+int main( int argc, char * argv[] ) {
+    switch ( argc ) {
+	  case 2:
+		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
+			Times = atoi( argv[1] );
+			if ( Times < 1 ) goto Usage;
+		} // if
+	  case 1:											// use defaults
+		break;
+	  default:
+	  Usage:
+		sout | "Usage: " | argv[0] | " [ times (> 0) ]";
+		exit( EXIT_FAILURE );
+	} // switch
+
+    printf("starting\n");
+
+    executor e{ 0, 1, 1, false };
+    start_actor_system( e );
+
+    printf("started\n");
+
+    derived_msg msg;
+
+    derived_actor actor;
+
+    actor | msg;
+
+    printf("stopping\n");
+
+    stop_actor_system();
+
+    printf("stopped\n");
+
+    return 0;
+}
Index: tests/concurrent/actors/types.cfa
===================================================================
--- tests/concurrent/actors/types.cfa	(revision 8a972486173f920eea1f1868fff138e1568a8a59)
+++ tests/concurrent/actors/types.cfa	(revision 2125443a425acb1ef9b560898cf33182c9f1dd8b)
@@ -5,4 +5,6 @@
 #include <stdio.h>
 #include <mutex_stmt.hfa>
+
+struct dummy_actor { actor a; }; // this won't work since the actor isn't inlined
 
 struct derived_actor {
@@ -26,8 +28,18 @@
 }
 
+Allocation receive( derived_actor & receiver, d_msg & msg ) {
+    return receive( receiver, msg.num );
+}
+
 struct derived_actor2 {
+    struct nested { int i; }; // testing nested before inline
     inline actor;
 };
 static inline void ?{}( derived_actor2 & this ) { ((actor &)this){}; }
+
+Allocation receive( derived_actor2 & receiver, d_msg & msg ) {
+    mutex(sout) sout | msg.num;
+    return Finished;
+}
 
 struct derived_actor3 {
@@ -41,13 +53,4 @@
 };
 static inline void ?{}( d_msg2 & this ) { ((message &)this){}; }
-
-Allocation receive( derived_actor2 & receiver, d_msg & msg ) {
-    mutex(sout) sout | msg.num;
-    return Finished;
-}
-
-Allocation receive( derived_actor & receiver, d_msg & msg ) {
-    return receive( receiver, msg.num );
-}
 
 Allocation receive( derived_actor3 & receiver, d_msg & msg ) {