Index: tests/concurrency/actors/.expect/dynamic.txt
===================================================================
--- tests/concurrency/actors/.expect/dynamic.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/.expect/dynamic.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,5 @@
+starting
+started
+stopping
+Done
+stopped
Index: tests/concurrency/actors/.expect/executor.txt
===================================================================
--- tests/concurrency/actors/.expect/executor.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/.expect/executor.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,4 @@
+starting
+started
+stopping
+stopped
Index: tests/concurrency/actors/.expect/inherit.txt
===================================================================
--- tests/concurrency/actors/.expect/inherit.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/.expect/inherit.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,6 @@
+Start
+A
+A
+A
+A
+Finished
Index: tests/concurrency/actors/.expect/matrix.txt
===================================================================
--- tests/concurrency/actors/.expect/matrix.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/.expect/matrix.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,4 @@
+starting
+started
+stopping
+stopped
Index: tests/concurrency/actors/.expect/pingpong.txt
===================================================================
--- tests/concurrency/actors/.expect/pingpong.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/.expect/pingpong.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,2 @@
+start
+end
Index: tests/concurrency/actors/.expect/poison.txt
===================================================================
--- tests/concurrency/actors/.expect/poison.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/.expect/poison.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,5 @@
+Start
+Finished
+Delete
+Destroy
+Done
Index: tests/concurrency/actors/.expect/static.txt
===================================================================
--- tests/concurrency/actors/.expect/static.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/.expect/static.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,5 @@
+starting
+started
+stopping
+Done
+stopped
Index: tests/concurrency/actors/.expect/types.txt
===================================================================
--- tests/concurrency/actors/.expect/types.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/.expect/types.txt	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,17 @@
+start
+basic test
+1
+2
+same message and different actors test
+3
+3
+same message and different actor types test
+4
+4
+different message types, one actor test
+-1
+5
+nested inheritance actor test
+-1
+5
+end
Index: tests/concurrency/actors/dynamic.cfa
===================================================================
--- tests/concurrency/actors/dynamic.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/dynamic.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,69 @@
+#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; };
+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/concurrency/actors/executor.cfa
===================================================================
--- tests/concurrency/actors/executor.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/executor.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,106 @@
+#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) {
+    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;
+
+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/concurrency/actors/inherit.cfa
===================================================================
--- tests/concurrency/actors/inherit.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/inherit.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,52 @@
+#include <actor.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>
+#include <string.h>
+#include <stdio.h>
+#include <mutex_stmt.hfa>
+
+struct Server { inline actor; };
+struct Server2 { inline Server; int b; };
+struct D_msg { int a; inline message; };
+struct D_msg2 { inline D_msg; };
+
+void ^?{}( Server2 & this ) { mutex(sout) sout | 'A'; }
+void ?{}( D_msg & this ) { set_allocation( this, Delete ); }
+void ^?{}( D_msg & this ) { mutex(sout) sout | 'A'; }
+
+Allocation handle() {
+    return Finished;
+}
+
+Allocation receive( Server & receiver, D_msg & msg ) { return handle(); }
+Allocation receive( Server & receiver, D_msg2 & msg ) { return handle(); }
+Allocation receive( Server2 & receiver, D_msg & msg ) { return Delete; }
+Allocation receive( Server2 & receiver, D_msg2 & msg ) { return Delete; }
+
+int main() {
+    sout | "Start";
+    {
+        start_actor_system();
+        D_msg * dm = alloc();
+        (*dm){};
+        D_msg2 dm2;
+        Server2 * s = alloc();
+        (*s){};
+        Server2 * s2 = alloc();
+        (*s2){};
+        *s << *dm;
+        *s2 << dm2;
+        stop_actor_system();
+    }
+    {
+        start_actor_system();
+        Server s[2];
+        D_msg * dm = alloc();
+        (*dm){};
+        D_msg2 dm2;
+        s[0] << *dm;
+        s[1] << dm2;
+        stop_actor_system();
+    }
+    sout | "Finished";
+}
Index: tests/concurrency/actors/matrix.cfa
===================================================================
--- tests/concurrency/actors/matrix.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/matrix.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,125 @@
+#include <actor.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>
+#include <string.h>
+#include <stdio.h>
+
+unsigned int xr = 500, xc = 500, yc = 500, Processors = 1; // default values
+
+struct derived_actor { inline actor; };
+
+struct derived_msg {
+    inline message;
+    int * Z;
+	int * X;
+    int ** Y;
+};
+
+void ?{}( derived_msg & this ) {}
+void ?{}( derived_msg & this, int * Z, int * X, int ** Y ) {
+    ((message &) this){ Nodelete };
+    this.Z = Z;
+    this.X = X;
+    this.Y = Y;
+}
+
+Allocation receive( derived_actor & receiver, derived_msg & msg ) {
+    for ( unsigned int i = 0; i < yc; i += 1 ) { // multiply X_row by Y_col and sum products
+        msg.Z[i] = 0;
+        for ( unsigned int j = 0; j < xc; j += 1 ) {
+            msg.Z[i] += msg.X[j] * msg.Y[j][i];
+        } // for
+    } // for
+    return Finished;
+}
+
+int main( int argc, char * argv[] ) {
+    switch ( argc ) {
+	  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 ?
+			xr = atoi( argv[3] );
+			if ( xr < 1 ) goto Usage;
+		} // if
+	  case 3:
+		if ( strcmp( argv[2], "d" ) != 0 ) {			// default ?
+			xc = atoi( argv[2] );
+			if ( xc < 1 ) goto Usage;
+		} // if
+	  case 2:
+		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
+			yc = atoi( argv[1] );
+			if ( yc < 1 ) goto Usage;
+		} // if
+	  case 1:											// use defaults
+		break;
+	  default:
+	  Usage:
+		sout | "Usage: " | argv[0]
+			 | " [ yc (> 0) | 'd' (default " | yc
+			 | ") ] [ xc (> 0) | 'd' (default " | xc
+			 | ") ] [ xr (> 0) | 'd' (default " | xr
+			 | ") ] [ processors (> 0) | 'd' (default " | Processors
+			 | ") ]" ;
+		exit( EXIT_FAILURE );
+	} // switch
+
+    unsigned int r, c;
+	int * Z[xr], * X[xr], * Y[xc];
+
+	for ( r = 0; r < xr; r += 1 ) {						// create/initialize X matrix
+		X[r] = aalloc( xc );
+		for ( c = 0; c < xc; c += 1 ) {
+			X[r][c] = r * c % 37;						// for timing
+		} // for
+	} // for
+	for ( r = 0; r < xc; r += 1 ) {						// create/initialize Y matrix
+		Y[r] = aalloc( yc );
+		for ( c = 0; c < yc; c += 1 ) {
+			Y[r][c] = r * c % 37;						// for timing
+		} // for
+	} // for
+	for ( r = 0; r < xr; r += 1 ) {						// create Z matrix
+		Z[r] = aalloc( yc );
+	} // for
+
+    executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 16, true };
+
+    printf("starting\n");
+
+    start_actor_system( e );
+
+    printf("started\n");
+
+    derived_msg messages[xr];
+
+    derived_actor actors[xr];
+
+	for ( unsigned int r = 0; r < xr; r += 1 ) {
+		messages[r]{ Z[r], X[r], Y };
+	} // for
+
+	for ( unsigned int r = 0; r < xr; r += 1 ) {
+		actors[r] << messages[r];
+	} // for
+
+    printf("stopping\n");
+
+    stop_actor_system();
+
+    printf("stopped\n");
+
+    for ( r = 0; r < xr; r += 1 ) {						// deallocate X and Z matrices
+		free( X[r] );
+        free( Z[r] );
+	} // for
+	for ( r = 0; r < xc; r += 1 ) {						// deallocate Y matrix
+        free( Y[r] );
+	} // for
+
+    return 0;
+}
Index: tests/concurrency/actors/pingpong.cfa
===================================================================
--- tests/concurrency/actors/pingpong.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/pingpong.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,60 @@
+#include <fstream.hfa>
+#include <stdlib.hfa>
+#include <string.h>
+#include <stdio.h>
+#include <mutex_stmt.hfa>
+#include <actor.hfa>
+
+struct ping { inline actor; };
+struct pong { inline actor; };
+
+struct p_msg {
+    inline message;
+    size_t count;
+};
+static inline void ?{}( p_msg & this ) { ((message &)this){}; this.count = 0; }
+
+ping * pi;
+pong * po;
+size_t times = 100000;
+
+Allocation receive( ping & receiver, p_msg & msg ) {
+    msg.count++;
+    if ( msg.count > times ) return Finished;
+
+    Allocation retval = Nodelete;
+    if ( msg.count == times ) retval = Finished;
+    *po << msg;
+    return retval;
+}
+
+Allocation receive( pong & receiver, p_msg & msg ) {
+    msg.count++;
+    if ( msg.count > times ) return Finished;
+    
+    Allocation retval = Nodelete;
+    if ( msg.count == times ) retval = Finished;
+    *pi << msg;
+    return retval;
+}
+
+size_t Processors = 2;
+
+int main( int argc, char * argv[] ) {
+    printf("start\n");
+
+    processor p[Processors - 1];
+
+    start_actor_system( Processors ); // test passing number of processors
+
+    ping pi_actor;
+    pong po_actor;
+    po = &po_actor;
+    pi = &pi_actor;
+    p_msg m;
+    pi_actor << m;
+    stop_actor_system();
+
+    printf("end\n");
+    return 0;
+}
Index: tests/concurrency/actors/poison.cfa
===================================================================
--- tests/concurrency/actors/poison.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/poison.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,50 @@
+#include <actor.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>
+#include <string.h>
+#include <stdio.h>
+
+struct Server { int val; inline actor; };
+
+void ?{}( Server & this ) { this.val = 999; }
+void ^?{}( Server & this ) { this.val = 777; }
+
+int main() {
+    sout | "Start";
+
+    sout | "Finished";
+    {
+        start_actor_system();
+        Server s[10];
+        for ( i; 10 ) {
+            s[i] << FinishedMsg;
+        }
+        stop_actor_system();
+    }
+
+    sout | "Delete";
+    {
+        start_actor_system();
+        for ( i; 10 ) {
+            Server * s = alloc();
+            (*s){};
+            (*s) << DeleteMsg;
+        }
+        stop_actor_system();
+    }
+
+    sout | "Destroy";
+    {
+        start_actor_system();
+        Server s[10];
+        for ( i; 10 )
+            s[i] << DestroyMsg;
+        stop_actor_system();
+        for ( i; 10 )
+            if (s[i].val != 777)
+                sout | "Error: dtor not called correctly.";
+    }
+
+    sout | "Done";
+    return 0;
+}
Index: tests/concurrency/actors/static.cfa
===================================================================
--- tests/concurrency/actors/static.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/static.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,66 @@
+#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; };
+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/concurrency/actors/types.cfa
===================================================================
--- tests/concurrency/actors/types.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
+++ tests/concurrency/actors/types.cfa	(revision c26bea2aa0f87b4b070349c5801adc32fb0d4cf9)
@@ -0,0 +1,128 @@
+#include <actor.hfa>
+#include <fstream.hfa>
+#include <stdlib.hfa>
+#include <string.h>
+#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 {
+    inline actor;
+    int counter;
+};
+static inline void ?{}( derived_actor & this ) { ((actor &)this){}; this.counter = 0; }
+
+struct d_msg {
+    inline message;
+    int num;
+};
+
+// this isn't a valid receive routine since int is not a message type
+Allocation receive( derived_actor & receiver, int i ) with( receiver ) {
+    mutex(sout) sout | i;
+    counter++;
+    if ( counter == 2 ) return Finished;
+    return Nodelete; 
+}
+
+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;
+};
+
+Allocation receive( derived_actor2 & receiver, d_msg & msg ) {
+    mutex(sout) sout | msg.num;
+    return Finished;
+}
+
+struct derived_actor3 { inline actor; };
+struct derived_actor4 { inline derived_actor3; };
+struct d_msg2 {
+    inline message;
+    int num;
+};
+
+Allocation receive( derived_actor3 & receiver, d_msg & msg ) {
+    mutex(sout) sout | msg.num;
+    if ( msg.num == -1 ) return Nodelete;
+    return Finished;
+}
+
+Allocation receive( derived_actor3 & receiver, d_msg2 & msg ) {
+    mutex(sout) sout | msg.num;
+    return Finished;
+}
+
+size_t Processors = 3;
+
+int main( int argc, char * argv[] ) {
+    printf("start\n");
+
+    processor p[Processors - 1];
+
+    printf("basic test\n"); 
+    start_actor_system( Processors ); // test passing number of processors
+    derived_actor a;
+    d_msg b, c;
+    b.num = 1;
+    c.num = 2;
+    a << b << c;
+    stop_actor_system();
+
+    printf("same message and different actors test\n");
+    start_actor_system(); // let system detect # of processors
+    derived_actor2 d_ac2_0, d_ac2_1;
+    d_msg d_ac2_msg;
+    d_ac2_msg.num = 3;
+    d_ac2_0 << d_ac2_msg;
+    d_ac2_1 << d_ac2_msg;
+    stop_actor_system();
+
+    
+    {
+        printf("same message and different actor types test\n");
+        executor e{ 0, Processors, Processors == 1 ? 1 : Processors * 4, false };
+        start_actor_system( e ); // pass an explicit executor
+        derived_actor2 d_ac2_2;
+        derived_actor3 d_ac3_0;
+        d_msg d_ac23_msg;
+        d_ac23_msg.num = 4;
+        d_ac3_0 << d_ac23_msg;
+        d_ac2_2 << d_ac23_msg;
+        stop_actor_system();
+    } // RAII to clean up executor
+
+    {
+        printf("different message types, one actor test\n");
+        executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
+        start_actor_system( Processors );
+        derived_actor3 a3;
+        d_msg b1;
+        d_msg2 c2;
+        b1.num = -1;
+        c2.num = 5;
+        a3 << b1 << c2;
+        stop_actor_system();
+    } // RAII to clean up executor
+
+    {
+        printf("nested inheritance actor test\n");
+        executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true };
+        start_actor_system( Processors );
+        derived_actor4 a4;
+        d_msg b1;
+        d_msg2 c2;
+        b1.num = -1;
+        c2.num = 5;
+        a4 << b1 << c2;
+        stop_actor_system();
+    } // RAII to clean up executor
+
+    printf("end\n");
+    return 0;
+}