diff --git a/lib/modules/exec.go b/lib/modules/exec.go
index 5ca6f09..341b60f 100644
--- a/lib/modules/exec.go
+++ b/lib/modules/exec.go
@@ -133,7 +133,10 @@
 	eh.mu.Lock()
 	defer eh.mu.Unlock()
 	eh.sh = sh
-	newargs := append(testFlags(), args...)
+	// Take care to not pass the command line as an arg to the child
+	// process since that'll prevent parsing any subsequent args by
+	// the flag package.
+	newargs := append(testFlags(), args[1:]...)
 	cmd := exec.Command(os.Args[0], newargs...)
 	cmd.Env = append(sh.mergeOSEnvSlice(), eh.entryPoint)
 	fname := strings.TrimPrefix(eh.entryPoint, ShellEntryPoint+"=")
@@ -280,7 +283,8 @@
 		}
 	}(os.Getppid())
 
-	return m.fn(os.Stdin, os.Stdout, os.Stderr, osEnvironMap(), flag.Args()...)
+	args := append([]string{command}, flag.Args()...)
+	return m.fn(os.Stdin, os.Stdout, os.Stderr, osEnvironMap(), args...)
 }
 
 func (child *childRegistrar) addSubprocesses(sh *Shell, pattern string) error {
diff --git a/lib/testutil/init.go b/lib/testutil/init.go
index 9cc119f..07fa6d4 100644
--- a/lib/testutil/init.go
+++ b/lib/testutil/init.go
@@ -20,6 +20,7 @@
 	// flag.Parse in init() is the right solution?
 	_ "testing"
 	"time"
+
 	_ "veyron.io/veyron/veyron/services/mgmt/suidhelper/impl/flag"
 
 	// Import blackbox to ensure that it gets to define its flags.
diff --git a/runtimes/google/rt/mgmt_test.go b/runtimes/google/rt/mgmt_test.go
index e15eaa2..bd0c97b 100644
--- a/runtimes/google/rt/mgmt_test.go
+++ b/runtimes/google/rt/mgmt_test.go
@@ -2,10 +2,12 @@
 
 import (
 	"fmt"
+	"io"
 	"os"
 	"reflect"
 	"strings"
 	"testing"
+	"time"
 
 	"veyron.io/veyron/veyron2"
 	"veyron.io/veyron/veyron2/ipc"
@@ -13,8 +15,9 @@
 	"veyron.io/veyron/veyron2/naming"
 	"veyron.io/veyron/veyron2/services/mgmt/appcycle"
 
+	"veyron.io/veyron/veyron/lib/expect"
+	"veyron.io/veyron/veyron/lib/modules"
 	_ "veyron.io/veyron/veyron/lib/testutil"
-	"veyron.io/veyron/veyron/lib/testutil/blackbox"
 	"veyron.io/veyron/veyron/lib/testutil/security"
 	"veyron.io/veyron/veyron/profiles"
 	"veyron.io/veyron/veyron/runtimes/google/rt"
@@ -22,6 +25,18 @@
 	"veyron.io/veyron/veyron/services/mgmt/node"
 )
 
+const (
+	noWaitersCmd = "noWaiters"
+	forceStopCmd = "forceStop"
+	appCmd       = "app"
+)
+
+func init() {
+	modules.RegisterChild(noWaitersCmd, "", noWaiters)
+	modules.RegisterChild(forceStopCmd, "", forceStop)
+	modules.RegisterChild(appCmd, "", app)
+}
+
 // TestBasic verifies that the basic plumbing works: LocalStop calls result in
 // stop messages being sent on the channel passed to WaitForStop.
 func TestBasic(t *testing.T) {
@@ -80,51 +95,57 @@
 	}
 }
 
-func init() {
-	blackbox.CommandTable["noWaiters"] = noWaiters
-}
-
-func noWaiters([]string) {
+func noWaiters(stdin io.Reader, stdout, stderr io.Writer, env map[string]string, args ...string) error {
 	m, _ := rt.New()
-	fmt.Println("ready")
-	blackbox.WaitForEOFOnStdin()
+	fmt.Fprintf(stdout, "ready\n")
+	modules.WaitForEOF(stdin)
 	m.Stop()
 	os.Exit(42) // This should not be reached.
+	return nil
 }
 
 // TestNoWaiters verifies that the child process exits in the absence of any
 // wait channel being registered with its runtime.
 func TestNoWaiters(t *testing.T) {
-	c := blackbox.HelperCommand(t, "noWaiters")
-	defer c.Cleanup()
-	c.Cmd.Start()
-	c.Expect("ready")
-	c.CloseStdin()
-	c.ExpectEOFAndWaitForExitCode(fmt.Errorf("exit status %d", veyron2.UnhandledStopExitCode))
+	sh := modules.NewShell(noWaitersCmd)
+	defer sh.Cleanup(os.Stderr, os.Stderr)
+	h, err := sh.Start(noWaitersCmd)
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	expect.NewSession(t, h.Stdout(), time.Minute).Expect("ready")
+	want := fmt.Sprintf("exit status %d", veyron2.UnhandledStopExitCode)
+	if err = h.Shutdown(os.Stderr, os.Stderr); err == nil || err.Error() != want {
+		t.Errorf("got %v, want %s", err, want)
+	}
 }
 
-func init() {
-	blackbox.CommandTable["forceStop"] = forceStop
-}
-
-func forceStop([]string) {
+func forceStop(stdin io.Reader, stdout, stderr io.Writer, env map[string]string, args ...string) error {
 	m, _ := rt.New()
-	fmt.Println("ready")
-	blackbox.WaitForEOFOnStdin()
+	fmt.Fprintf(stdout, "ready\n")
+	modules.WaitForEOF(stdin)
 	m.WaitForStop(make(chan string, 1))
 	m.ForceStop()
 	os.Exit(42) // This should not be reached.
+	return nil
 }
 
 // TestForceStop verifies that ForceStop causes the child process to exit
 // immediately.
 func TestForceStop(t *testing.T) {
-	c := blackbox.HelperCommand(t, "forceStop")
-	defer c.Cleanup()
-	c.Cmd.Start()
-	c.Expect("ready")
-	c.CloseStdin()
-	c.ExpectEOFAndWaitForExitCode(fmt.Errorf("exit status %d", veyron2.ForceStopExitCode))
+	sh := modules.NewShell(forceStopCmd)
+	defer sh.Cleanup(os.Stderr, os.Stderr)
+	h, err := sh.Start(forceStopCmd)
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	s := expect.NewSession(t, h.Stdout(), time.Minute)
+	s.Expect("ready")
+	err = h.Shutdown(os.Stderr, os.Stderr)
+	want := fmt.Sprintf("exit status %d", veyron2.UnhandledStopExitCode)
+	if err == nil || err.Error() != want {
+		t.Errorf("got %v, want %s", err, want)
+	}
 }
 
 func checkProgress(t *testing.T, ch <-chan veyron2.Task, progress, goal int) {
@@ -206,25 +227,21 @@
 	}
 }
 
-func init() {
-	blackbox.CommandTable["app"] = app
-}
-
-func app([]string) {
+func app(stdin io.Reader, stdout, stderr io.Writer, env map[string]string, args ...string) error {
 	r, err := rt.New()
 	if err != nil {
-		fmt.Printf("Error creating runtime: %v\n", err)
-		return
+		return err
 	}
 	defer r.Cleanup()
 	ch := make(chan string, 1)
 	r.WaitForStop(ch)
-	fmt.Printf("Got %s\n", <-ch)
+	fmt.Fprintf(stdout, "Got %s\n", <-ch)
 	r.AdvanceGoal(10)
-	fmt.Println("Doing some work")
+	fmt.Fprintf(stdout, "Doing some work\n")
 	r.AdvanceProgress(2)
-	fmt.Println("Doing some more work")
+	fmt.Fprintf(stdout, "Doing some more work\n")
 	r.AdvanceProgress(5)
+	return nil
 }
 
 type configServer struct {
@@ -258,27 +275,30 @@
 
 }
 
-func setupRemoteAppCycleMgr(t *testing.T) (veyron2.Runtime, *blackbox.Child, appcycle.AppCycle, func()) {
+func setupRemoteAppCycleMgr(t *testing.T) (veyron2.Runtime, modules.Handle, appcycle.AppCycle, func()) {
 	// We need to use the public API since stubs are used below (and they
 	// refer to the global rt.R() function), but we take care to make sure
 	// that the "google" runtime we are trying to test in this package is
 	// the one being used.
 	r, _ := rt.New(veyron2.RuntimeOpt{veyron2.GoogleRuntimeName}, veyron2.ForceNewSecurityModel{})
-	c := blackbox.HelperCommand(t, "app")
-	childcreds := security.NewVeyronCredentials(r.Principal(), "app")
+
 	configServer, configServiceName, ch := createConfigServer(t, r)
-	c.Cmd.Env = append(c.Cmd.Env, fmt.Sprintf("VEYRON_CREDENTIALS=%v", childcreds),
-		fmt.Sprintf("%v=%v", mgmt.ParentNodeManagerConfigKey, configServiceName))
-	c.Cmd.Start()
+	sh := modules.NewShell(appCmd)
+	sh.SetVar("VEYRON_CREDENTIALS", security.NewVeyronCredentials(r.Principal(), appCmd))
+	sh.SetVar(mgmt.ParentNodeManagerConfigKey, configServiceName)
+	h, err := sh.Start("app")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+
 	appCycleName := <-ch
 	appCycle, err := appcycle.BindAppCycle(appCycleName)
 	if err != nil {
 		t.Fatalf("Got error: %v", err)
 	}
-	return r, c, appCycle, func() {
+	return r, h, appCycle, func() {
 		configServer.Stop()
-		c.Cleanup()
-		os.RemoveAll(childcreds)
+		sh.Cleanup(os.Stderr, os.Stderr)
 		// Don't do r.Cleanup() since the runtime needs to be used by
 		// more than one test case.
 	}
@@ -287,18 +307,25 @@
 // TestRemoteForceStop verifies that the child process exits when sending it
 // a remote ForceStop rpc.
 func TestRemoteForceStop(t *testing.T) {
-	r, c, appCycle, cleanup := setupRemoteAppCycleMgr(t)
+	r, h, appCycle, cleanup := setupRemoteAppCycleMgr(t)
 	defer cleanup()
 	if err := appCycle.ForceStop(r.NewContext()); err == nil || !strings.Contains(err.Error(), "EOF") {
 		t.Fatalf("Expected EOF error, got %v instead", err)
 	}
-	c.ExpectEOFAndWaitForExitCode(fmt.Errorf("exit status %d", veyron2.ForceStopExitCode))
+	s := expect.NewSession(t, h.Stdout(), time.Minute)
+	s.ExpectEOF()
+	err := h.Shutdown(os.Stderr, os.Stderr)
+	want := fmt.Sprintf("exit status %d", veyron2.ForceStopExitCode)
+	if err == nil || err.Error() != want {
+		t.Errorf("got %v, want %s", err, want)
+	}
+
 }
 
 // TestRemoteStop verifies that the child shuts down cleanly when sending it
 // a remote Stop rpc.
 func TestRemoteStop(t *testing.T) {
-	r, c, appCycle, cleanup := setupRemoteAppCycleMgr(t)
+	r, h, appCycle, cleanup := setupRemoteAppCycleMgr(t)
 	defer cleanup()
 	stream, err := appCycle.Stop(r.NewContext())
 	if err != nil {
@@ -323,8 +350,12 @@
 	if err := stream.Finish(); err != nil {
 		t.Errorf("Got error %v", err)
 	}
-	c.Expect(fmt.Sprintf("Got %s", veyron2.RemoteStop))
-	c.Expect("Doing some work")
-	c.Expect("Doing some more work")
-	c.ExpectEOFAndWait()
+	s := expect.NewSession(t, h.Stdout(), time.Minute)
+	s.Expect(fmt.Sprintf("Got %s", veyron2.RemoteStop))
+	s.Expect("Doing some work")
+	s.Expect("Doing some more work")
+	s.ExpectEOF()
+	if err := h.Shutdown(os.Stderr, os.Stderr); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
 }
diff --git a/runtimes/google/rt/rt_test.go b/runtimes/google/rt/rt_test.go
index 4faaf1c..51f2031 100644
--- a/runtimes/google/rt/rt_test.go
+++ b/runtimes/google/rt/rt_test.go
@@ -2,21 +2,24 @@
 
 import (
 	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
 	"reflect"
 	"regexp"
 	"testing"
-
-	_ "veyron.io/veyron/veyron/lib/testutil"
-	"veyron.io/veyron/veyron/lib/testutil/blackbox"
-	irt "veyron.io/veyron/veyron/runtimes/google/rt"
+	"time"
 
 	"veyron.io/veyron/veyron2"
 	"veyron.io/veyron/veyron2/naming"
 	"veyron.io/veyron/veyron2/rt"
 	"veyron.io/veyron/veyron2/security"
 	"veyron.io/veyron/veyron2/vlog"
+
+	"veyron.io/veyron/veyron/lib/expect"
+	"veyron.io/veyron/veyron/lib/modules"
+	_ "veyron.io/veyron/veyron/lib/testutil"
+	irt "veyron.io/veyron/veyron/runtimes/google/rt"
 )
 
 type context struct {
@@ -37,11 +40,11 @@
 func (*context) RemoteEndpoint() naming.Endpoint           { return nil }
 
 func init() {
-	blackbox.CommandTable["child"] = child
+	modules.RegisterChild("child", "", child)
 }
 
 func TestHelperProcess(t *testing.T) {
-	blackbox.HelperProcess(t)
+	modules.DispatchInTest()
 }
 
 func TestInit(t *testing.T) {
@@ -60,24 +63,24 @@
 	}
 }
 
-func child(argv []string) {
+func child(stdin io.Reader, stdout, stderr io.Writer, env map[string]string, args ...string) error {
 	r := rt.Init()
 	vlog.Infof("%s\n", r.Logger())
-	fmt.Printf("%s\n", r.Logger())
-	_ = r
-	blackbox.WaitForEOFOnStdin()
+	fmt.Fprintf(stdout, "%s\n", r.Logger())
+	modules.WaitForEOF(stdin)
 	fmt.Printf("done\n")
+	return nil
 }
 
 func TestInitArgs(t *testing.T) {
-	c := blackbox.HelperCommand(t, "child", "--logtostderr=true", "--vv=3", "--", "foobar")
-	defer c.Cleanup()
-	c.Cmd.Start()
-	str, err := c.ReadLineFromChild()
+	sh := modules.NewShell("child")
+	defer sh.Cleanup(os.Stderr, os.Stderr)
+	h, err := sh.Start("child", "--logtostderr=true", "--vv=3", "--", "foobar")
 	if err != nil {
-		t.Fatalf("failed to read from child: %v", err)
+		t.Fatalf("unexpected error: %s", err)
 	}
-	expected := fmt.Sprintf("name=veyron "+
+	s := expect.NewSession(t, h.Stdout(), time.Minute)
+	s.Expect(fmt.Sprintf("name=veyron "+
 		"logdirs=[%s] "+
 		"logtostderr=true "+
 		"alsologtostderr=true "+
@@ -86,14 +89,11 @@
 		"stderrthreshold=2 "+
 		"vmodule= "+
 		"log_backtrace_at=:0",
-		os.TempDir())
-
-	if str != expected {
-		t.Fatalf("incorrect child output: got %s, expected %s", str, expected)
-	}
-	c.CloseStdin()
-	c.Expect("done")
-	c.ExpectEOFAndWait()
+		os.TempDir()))
+	h.CloseStdin()
+	s.Expect("done")
+	s.ExpectEOF()
+	h.Shutdown(os.Stderr, os.Stderr)
 }
 
 func TestInitPrincipal(t *testing.T) {
diff --git a/runtimes/google/rt/signal_test.go b/runtimes/google/rt/signal_test.go
index c0f6235..5c400a9 100644
--- a/runtimes/google/rt/signal_test.go
+++ b/runtimes/google/rt/signal_test.go
@@ -1,56 +1,82 @@
 package rt_test
 
 import (
+	"bufio"
 	"fmt"
+	"io"
+	"os"
 	"syscall"
 	"testing"
+	"time"
 
 	"veyron.io/veyron/veyron2"
 	"veyron.io/veyron/veyron2/rt"
 
-	"veyron.io/veyron/veyron/lib/testutil/blackbox"
+	"veyron.io/veyron/veyron/lib/expect"
+	"veyron.io/veyron/veyron/lib/modules"
 )
 
 func init() {
-	blackbox.CommandTable["withRuntime"] = withRuntime
-	blackbox.CommandTable["withoutRuntime"] = withoutRuntime
+	modules.RegisterChild("withRuntime", "", withRuntime)
+	modules.RegisterChild("withoutRuntime", "", withoutRuntime)
 }
 
-func simpleEchoProgram() {
-	fmt.Println("ready")
-	fmt.Println(blackbox.ReadLineFromStdin())
-	blackbox.WaitForEOFOnStdin()
+func simpleEchoProgram(stdin io.Reader, stdout io.Writer) {
+	fmt.Fprintf(stdout, "ready\n")
+	scanner := bufio.NewScanner(stdin)
+	if scanner.Scan() {
+		fmt.Fprintf(stdout, "%s\n", scanner.Text())
+	}
+	modules.WaitForEOF(stdin)
 }
 
-func withRuntime([]string) {
+func withRuntime(stdin io.Reader, stdout, stderr io.Writer, env map[string]string, args ...string) error {
 	// Make sure that we use "google" runtime implementation in this
 	// package even though we have to use the public API which supports
 	// arbitrary runtime implementations.
 	rt.Init(veyron2.RuntimeOpt{veyron2.GoogleRuntimeName})
-	simpleEchoProgram()
+	simpleEchoProgram(stdin, stdout)
+	return nil
 }
 
-func withoutRuntime([]string) {
-	simpleEchoProgram()
+func withoutRuntime(stdin io.Reader, stdout, stderr io.Writer, env map[string]string, args ...string) error {
+	simpleEchoProgram(stdin, stdout)
+	return nil
 }
 
 func TestWithRuntime(t *testing.T) {
-	c := blackbox.HelperCommand(t, "withRuntime")
-	defer c.Cleanup()
-	c.Cmd.Start()
-	c.Expect("ready")
-	syscall.Kill(c.Cmd.Process.Pid, syscall.SIGHUP)
-	c.WriteLine("foo")
-	c.Expect("foo")
-	c.CloseStdin()
-	c.ExpectEOFAndWait()
+	sh := modules.NewShell("withRuntime")
+	defer sh.Cleanup(os.Stderr, os.Stderr)
+	h, err := sh.Start("withRuntime")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	defer h.Shutdown(os.Stderr, os.Stderr)
+	s := expect.NewSession(t, h.Stdout(), time.Minute)
+	s.Expect("ready")
+	syscall.Kill(h.Pid(), syscall.SIGHUP)
+	h.Stdin().Write([]byte("foo\n"))
+	s.Expect("foo")
+	h.CloseStdin()
+	s.ExpectEOF()
 }
 
 func TestWithoutRuntime(t *testing.T) {
-	c := blackbox.HelperCommand(t, "withoutRuntime")
-	defer c.Cleanup()
-	c.Cmd.Start()
-	c.Expect("ready")
-	syscall.Kill(c.Cmd.Process.Pid, syscall.SIGHUP)
-	c.ExpectEOFAndWaitForExitCode(fmt.Errorf("exit status 2"))
+	sh := modules.NewShell("withoutRuntime")
+	defer sh.Cleanup(os.Stderr, os.Stderr)
+	h, err := sh.Start("withoutRuntime")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	defer h.Shutdown(os.Stderr, os.Stderr)
+	s := expect.NewSession(t, h.Stdout(), time.Minute)
+	s.Expect("ready")
+	syscall.Kill(h.Pid(), syscall.SIGHUP)
+	s.ExpectEOF()
+	err = h.Shutdown(os.Stderr, os.Stderr)
+	want := "exit status 2"
+	if err == nil || err.Error() != want {
+		t.Errorf("got %s, want %s", err, want)
+
+	}
 }