@@ -526,43 +526,36 @@ func postContainersCreate(srv *Server, version float64, w http.ResponseWriter, r

 	if err := parseForm(r); err != nil {

 		return nil

 	}

-	config := &Config{}

 	out := &APIRun{}

-	name := r.Form.Get("name")

-

-	if err := json.NewDecoder(r.Body).Decode(config); err != nil {

+	job := srv.Eng.Job("create", r.Form.Get("name"))

+	if err := job.DecodeEnv(r.Body); err != nil {

 		return err

 	}

-

 	resolvConf, err := utils.GetResolvConf()

 	if err != nil {

 		return err

 	}

-

-	if !config.NetworkDisabled && len(config.Dns) == 0 && len(srv.runtime.config.Dns) == 0 && utils.CheckLocalDns(resolvConf) {

+	if !job.GetenvBool("NetworkDisabled") && len(job.Getenv("Dns")) == 0 && len(srv.runtime.config.Dns) == 0 && utils.CheckLocalDns(resolvConf) {

 		out.Warnings = append(out.Warnings, fmt.Sprintf("Docker detected local DNS server on resolv.conf. Using default external servers: %v", defaultDns))

-		config.Dns = defaultDns

+		job.SetenvList("Dns", defaultDns)

 	}

-

-	id, warnings, err := srv.ContainerCreate(config, name)

-	if err != nil {

+	// Read container ID from the first line of stdout

+	job.StdoutParseString(&out.ID)

+	// Read warnings from stderr

+	job.StderrParseLines(&out.Warnings, 0)

+	if err := job.Run(); err != nil {

 		return err

 	}

-	out.ID = id

-	for _, warning := range warnings {

-		out.Warnings = append(out.Warnings, warning)

-	}

-

-	if config.Memory > 0 && !srv.runtime.capabilities.MemoryLimit {

+	if job.GetenvInt("Memory") > 0 && !srv.runtime.capabilities.MemoryLimit {

 		log.Println("WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.")

 		out.Warnings = append(out.Warnings, "Your kernel does not support memory limit capabilities. Limitation discarded.")

 	}

-	if config.Memory > 0 && !srv.runtime.capabilities.SwapLimit {

+	if job.GetenvInt("Memory") > 0 && !srv.runtime.capabilities.SwapLimit {

 		log.Println("WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.")

 		out.Warnings = append(out.Warnings, "Your kernel does not support memory swap capabilities. Limitation discarded.")

 	}

-	if !config.NetworkDisabled && srv.runtime.capabilities.IPv4ForwardingDisabled {

+	if !job.GetenvBool("NetworkDisabled") && srv.runtime.capabilities.IPv4ForwardingDisabled {

 		log.Println("Warning: IPv4 forwarding is disabled.")

 		out.Warnings = append(out.Warnings, "IPv4 forwarding is disabled.")

 	}

@@ -634,11 +634,11 @@ func TestPostCommit(t *testing.T) {

 }

 func TestPostContainersCreate(t *testing.T) {

-	runtime := mkRuntime(t)

+	eng := NewTestEngine(t)

+	srv := mkServerFromEngine(eng, t)

+	runtime := srv.runtime

 	defer nuke(runtime)

-	srv := &Server{runtime: runtime}

-

 	configJSON, err := json.Marshal(&Config{

 		Image:  GetTestImage(runtime).ID,

 		Memory: 33554432,

@@ -786,22 +786,18 @@ func TestPostContainersStart(t *testing.T) {

 	runtime := srv.runtime

 	defer nuke(runtime)

-	container, _, err := runtime.Create(

+	id := createTestContainer(

+		eng,

 		&Config{

 			Image:     GetTestImage(runtime).ID,

 			Cmd:       []string{"/bin/cat"},

 			OpenStdin: true,

 		},

-		"",

-	)

-	if err != nil {

-		t.Fatal(err)

-	}

-	defer runtime.Destroy(container)

+		t)

 	hostConfigJSON, err := json.Marshal(&HostConfig{})

-	req, err := http.NewRequest("POST", "/containers/"+container.ID+"/start", bytes.NewReader(hostConfigJSON))

+	req, err := http.NewRequest("POST", "/containers/"+id+"/start", bytes.NewReader(hostConfigJSON))

 	if err != nil {

 		t.Fatal(err)

 	}

@@ -809,22 +805,26 @@ func TestPostContainersStart(t *testing.T) {

 	req.Header.Set("Content-Type", "application/json")

 	r := httptest.NewRecorder()

-	if err := postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil {

+	if err := postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": id}); err != nil {

 		t.Fatal(err)

 	}

 	if r.Code != http.StatusNoContent {

 		t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code)

 	}

+	container := runtime.Get(id)

+	if container == nil {

+		t.Fatalf("Container %s was not created", id)

+	}

 	// Give some time to the process to start

+	// FIXME: use Wait once it's available as a job

 	container.WaitTimeout(500 * time.Millisecond)

-

 	if !container.State.Running {

 		t.Errorf("Container should be running")

 	}

 	r = httptest.NewRecorder()

-	if err = postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err == nil {

+	if err = postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": id}); err == nil {

 		t.Fatalf("A running container should be able to be started")

 	}

@@ -115,5 +115,5 @@ func (eng *Engine) Job(name string, args ...string) *Job {

 func (eng *Engine) Logf(format string, args ...interface{}) (n int, err error) {

 	prefixedFormat := fmt.Sprintf("[%s] %s\n", eng, strings.TrimRight(format, "\n"))

-	return fmt.Printf(prefixedFormat, args...)

+	return fmt.Fprintf(os.Stderr, prefixedFormat, args...)

 }

@@ -1,11 +1,16 @@

 package engine

 import (

+	"bufio"

 	"bytes"

 	"io"

+	"io/ioutil"

+	"strconv"

 	"strings"

 	"fmt"

+	"sync"

 	"encoding/json"

+	"os"

 )

 // A job is the fundamental unit of work in the docker engine.

@@ -26,20 +31,38 @@ type Job struct {

 	Name	string

 	Args	[]string

 	env	[]string

-	Stdin	io.ReadCloser

-	Stdout	io.WriteCloser

-	Stderr	io.WriteCloser

+	Stdin	io.Reader

+	Stdout	io.Writer

+	Stderr	io.Writer

 	handler	func(*Job) string

 	status	string

+	onExit	[]func()

 }

 // Run executes the job and blocks until the job completes.

 // If the job returns a failure status, an error is returned

 // which includes the status.

 func (job *Job) Run() error {

-	job.Logf("{")

 	defer func() {

-		job.Logf("}")

+		var wg sync.WaitGroup

+		for _, f := range job.onExit {

+			wg.Add(1)

+			go func(f func()) {

+				f()

+				wg.Done()

+			}(f)

+		}

+		wg.Wait()

+	}()

+	if job.Stdout != nil && job.Stdout != os.Stdout {

+		job.Stdout = io.MultiWriter(job.Stdout, os.Stdout)

+	}

+	if job.Stderr != nil && job.Stderr != os.Stderr {

+		job.Stderr = io.MultiWriter(job.Stderr, os.Stderr)

+	}

+	job.Eng.Logf("+job %s", job.CallString())

+	defer func() {

+		job.Eng.Logf("-job %s%s", job.CallString(), job.StatusString())

 	}()

 	if job.handler == nil {

 		job.status = "command not found"

@@ -52,9 +75,66 @@ func (job *Job) Run() error {

 	return nil

 }

-// String returns a human-readable description of `job`

-func (job *Job) String() string {

-	s := fmt.Sprintf("%s.%s(%s)", job.Eng, job.Name, strings.Join(job.Args, ", "))

+func (job *Job) StdoutParseLines(dst *[]string, limit int) {

+	job.parseLines(job.StdoutPipe(), dst, limit)

+}

+

+func (job *Job) StderrParseLines(dst *[]string, limit int) {

+	job.parseLines(job.StderrPipe(), dst, limit)

+}

+

+func (job *Job) parseLines(src io.Reader, dst *[]string, limit int) {

+	var wg sync.WaitGroup

+	wg.Add(1)

+	go func() {

+		defer wg.Done()

+		scanner := bufio.NewScanner(src)

+		for scanner.Scan() {

+			// If the limit is reached, flush the rest of the source and return

+			if limit > 0 && len(*dst) >= limit {

+				io.Copy(ioutil.Discard, src)

+				return

+			}

+			line := scanner.Text()

+			// Append the line (with delimitor removed)

+			*dst = append(*dst, line)

+		}

+	}()

+	job.onExit = append(job.onExit, wg.Wait)

+}

+

+func (job *Job) StdoutParseString(dst *string) {

+	lines := make([]string, 0, 1)

+	job.StdoutParseLines(&lines, 1)

+	job.onExit = append(job.onExit, func() { if len(lines) >= 1 { *dst = lines[0] }})

+}

+

+func (job *Job) StderrParseString(dst *string) {

+	lines := make([]string, 0, 1)

+	job.StderrParseLines(&lines, 1)

+	job.onExit = append(job.onExit, func() { *dst = lines[0]; })

+}

+

+func (job *Job) StdoutPipe() io.ReadCloser {

+	r, w := io.Pipe()

+	job.Stdout = w

+	job.onExit = append(job.onExit, func(){ w.Close() })

+	return r

+}

+

+func (job *Job) StderrPipe() io.ReadCloser {

+	r, w := io.Pipe()

+	job.Stderr = w

+	job.onExit = append(job.onExit, func(){ w.Close() })

+	return r

+}

+

+

+func (job *Job) CallString() string {

+	return fmt.Sprintf("%s(%s)", job.Name, strings.Join(job.Args, ", "))

+}

+

+func (job *Job) StatusString() string {

 	// FIXME: if a job returns the empty string, it will be printed

 	// as not having returned.

 	// (this only affects String which is a convenience function).

@@ -65,9 +145,14 @@ func (job *Job) String() string {

 		} else {

 			okerr = "ERR"

 		}

-		s = fmt.Sprintf("%s = %s (%s)", s, okerr, job.status)

+		return fmt.Sprintf(" = %s (%s)", okerr, job.status)

 	}

-	return s

+	return ""

+}

+

+// String returns a human-readable description of `job`

+func (job *Job) String() string {

+	return fmt.Sprintf("%s.%s%s", job.Eng, job.CallString(), job.StatusString())

 }

 func (job *Job) Getenv(key string) (value string) {

@@ -104,6 +189,19 @@ func (job *Job) SetenvBool(key string, value bool) {

 	}

 }

+func (job *Job) GetenvInt(key string) int64 {

+	s := strings.Trim(job.Getenv(key), " \t")

+	val, err := strconv.ParseInt(s, 10, 64)

+	if err != nil {

+		return -1

+	}

+	return val

+}

+

+func (job *Job) SetenvInt(key string, value int64) {

+	job.Setenv(key, fmt.Sprintf("%d", value))

+}

+

 func (job *Job) GetenvList(key string) []string {

 	sval := job.Getenv(key)

 	l := make([]string, 0, 1)

@@ -137,13 +235,21 @@ func (job *Job) DecodeEnv(src io.Reader) error {

 		return err

 	}

 	for k, v := range m {

-		if sval, ok := v.(string); ok {

+		// FIXME: we fix-convert float values to int, because

+		// encoding/json decodes integers to float64, but cannot encode them back.

+		// (See http://golang.org/src/pkg/encoding/json/decode.go#L46)

+		if fval, ok := v.(float64); ok {

+			job.Logf("Converted to float: %v->%v", v, fval)

+			job.SetenvInt(k, int64(fval))

+		} else if sval, ok := v.(string); ok {

+			job.Logf("Converted to string: %v->%v", v, sval)

 			job.Setenv(k, sval)

 		} else	if val, err := json.Marshal(v); err == nil {

 			job.Setenv(k, string(val))

 		} else {

 			job.Setenv(k, fmt.Sprintf("%v", v))

 		}

+		job.Logf("Decoded %s=%#v to %s=%#v", k, v, k, job.Getenv(k))

 	}

 	return nil

 }

@@ -153,10 +259,17 @@ func (job *Job) EncodeEnv(dst io.Writer) error {

 	for k, v := range job.Environ() {

 		var val interface{}

 		if err := json.Unmarshal([]byte(v), &val); err == nil {

+			// FIXME: we fix-convert float values to int, because

+			// encoding/json decodes integers to float64, but cannot encode them back.

+			// (See http://golang.org/src/pkg/encoding/json/decode.go#L46)

+			if fval, isFloat := val.(float64); isFloat {

+				val = int(fval)

+			}

 			m[k] = val

 		} else {

 			m[k] = v

 		}

+		job.Logf("Encoded %s=%#v to %s=%#v", k, v, k, m[k])

 	}

 	if err := json.NewEncoder(dst).Encode(&m); err != nil {

 		return err

@@ -165,21 +278,38 @@ func (job *Job) EncodeEnv(dst io.Writer) error {

 }

 func (job *Job) ExportEnv(dst interface{}) (err error) {

+	fmt.Fprintf(os.Stderr, "ExportEnv()\n")

+	defer func() {

+		if err != nil {

+			err = fmt.Errorf("ExportEnv %s", err)

+		}

+	}()

 	var buf bytes.Buffer

+	job.Logf("ExportEnv: step 1: encode/marshal the env to an intermediary json representation")

+	fmt.Fprintf(os.Stderr, "Printed ExportEnv step 1\n")

 	if err := job.EncodeEnv(&buf); err != nil {

 		return err

 	}

+	job.Logf("ExportEnv: step 1 complete: json=|%s|", buf)

+	job.Logf("ExportEnv: step 2: decode/unmarshal the intermediary json into the destination object")

 	if err := json.NewDecoder(&buf).Decode(dst); err != nil {

 		return err

 	}

+	job.Logf("ExportEnv: step 2 complete")

 	return nil

 }

-func (job *Job) ImportEnv(src interface{}) error {

+func (job *Job) ImportEnv(src interface{}) (err error) {

+	defer func() {

+		if err != nil {

+			err = fmt.Errorf("ImportEnv: %s", err)

+		}

+	}()

 	var buf bytes.Buffer

 	if err := json.NewEncoder(&buf).Encode(src); err != nil {

 		return err

 	}

+	job.Logf("ImportEnv: json=|%s|", buf)

 	if err := job.DecodeEnv(&buf); err != nil {

 		return err

 	}

@@ -197,5 +327,14 @@ func (job *Job) Environ() map[string]string {

 func (job *Job) Logf(format string, args ...interface{}) (n int, err error) {

 	prefixedFormat := fmt.Sprintf("[%s] %s\n", job, strings.TrimRight(format, "\n"))

-	return fmt.Fprintf(job.Stdout, prefixedFormat, args...)

+	return fmt.Fprintf(job.Stderr, prefixedFormat, args...)

+}

+

+func (job *Job) Printf(format string, args ...interface{}) (n int, err error) {

+	return fmt.Fprintf(job.Stdout, format, args...)

+}

+

+func (job *Job) Errorf(format string, args ...interface{}) (n int, err error) {

+	return fmt.Fprintf(job.Stderr, format, args...)

+

 }

@@ -645,20 +645,17 @@ func TestReloadContainerLinks(t *testing.T) {

 }

 func TestDefaultContainerName(t *testing.T) {

-	runtime := mkRuntime(t)

+	eng := NewTestEngine(t)

+	srv := mkServerFromEngine(eng, t)

+	runtime := srv.runtime

 	defer nuke(runtime)

-	srv := &Server{runtime: runtime}

 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)

 	if err != nil {

 		t.Fatal(err)

 	}

-	shortId, _, err := srv.ContainerCreate(config, "some_name")

-	if err != nil {

-		t.Fatal(err)

-	}

-	container := runtime.Get(shortId)

+	container := runtime.Get(createNamedTestContainer(eng, config, t, "some_name"))

 	containerID := container.ID

 	if container.Name != "/some_name" {

@@ -682,20 +679,17 @@ func TestDefaultContainerName(t *testing.T) {

 }

 func TestRandomContainerName(t *testing.T) {

-	runtime := mkRuntime(t)

+	eng := NewTestEngine(t)

+	srv := mkServerFromEngine(eng, t)

+	runtime := srv.runtime

 	defer nuke(runtime)

-	srv := &Server{runtime: runtime}

 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)

 	if err != nil {

 		t.Fatal(err)

 	}

-	shortId, _, err := srv.ContainerCreate(config, "")

-	if err != nil {

-		t.Fatal(err)

-	}

-	container := runtime.Get(shortId)

+	container := runtime.Get(createTestContainer(eng, config, t))

 	containerID := container.ID

 	if container.Name == "" {

@@ -719,20 +713,17 @@ func TestRandomContainerName(t *testing.T) {

 }

 func TestLinkChildContainer(t *testing.T) {

-	runtime := mkRuntime(t)

+	eng := NewTestEngine(t)

+	srv := mkServerFromEngine(eng, t)

+	runtime := srv.runtime

 	defer nuke(runtime)

-	srv := &Server{runtime: runtime}

 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)

 	if err != nil {

 		t.Fatal(err)

 	}

-	shortId, _, err := srv.ContainerCreate(config, "/webapp")

-	if err != nil {

-		t.Fatal(err)

-	}

-	container := runtime.Get(shortId)

+	container := runtime.Get(createNamedTestContainer(eng, config, t, "/webapp"))

 	webapp, err := runtime.GetByName("/webapp")

 	if err != nil {

@@ -748,12 +739,7 @@ func TestLinkChildContainer(t *testing.T) {

 		t.Fatal(err)

 	}

-	shortId, _, err = srv.ContainerCreate(config, "")

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	childContainer := runtime.Get(shortId)

+	childContainer := runtime.Get(createTestContainer(eng, config, t))

 	if err := runtime.RegisterLink(webapp, childContainer, "db"); err != nil {

 		t.Fatal(err)

@@ -770,20 +756,17 @@ func TestLinkChildContainer(t *testing.T) {

 }

 func TestGetAllChildren(t *testing.T) {

-	runtime := mkRuntime(t)

+	eng := NewTestEngine(t)

+	srv := mkServerFromEngine(eng, t)

+	runtime := srv.runtime

 	defer nuke(runtime)

-	srv := &Server{runtime: runtime}

 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)

 	if err != nil {

 		t.Fatal(err)

 	}

-	shortId, _, err := srv.ContainerCreate(config, "/webapp")

-	if err != nil {

-		t.Fatal(err)

-	}

-	container := runtime.Get(shortId)

+	container := runtime.Get(createNamedTestContainer(eng, config, t, "/webapp"))

 	webapp, err := runtime.GetByName("/webapp")

 	if err != nil {

@@ -799,12 +782,7 @@ func TestGetAllChildren(t *testing.T) {

 		t.Fatal(err)

 	}

-	shortId, _, err = srv.ContainerCreate(config, "")

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	childContainer := runtime.Get(shortId)

+	childContainer := runtime.Get(createTestContainer(eng, config, t))

 	if err := runtime.RegisterLink(webapp, childContainer, "db"); err != nil {

 		t.Fatal(err)

@@ -62,6 +62,9 @@ func jobInitApi(job *engine.Job) string {

 		os.Exit(0)

 	}()

 	job.Eng.Hack_SetGlobalVar("httpapi.server", srv)

+	if err := job.Eng.Register("create", srv.ContainerCreate); err != nil {

+		return err.Error()

+	}

 	if err := job.Eng.Register("start", srv.ContainerStart); err != nil {

 		return err.Error()

 	}

@@ -1009,33 +1012,43 @@ func (srv *Server) ImageImport(src, repo, tag string, in io.Reader, out io.Write

 	return nil

 }

-func (srv *Server) ContainerCreate(config *Config, name string) (string, []string, error) {

+func (srv *Server) ContainerCreate(job *engine.Job) string {

+	var name string

+	if len(job.Args) == 1 {

+		name = job.Args[0]

+	} else if len(job.Args) > 1 {

+		return fmt.Sprintf("Usage: %s ", job.Name)

+	}

+	var config Config

+	if err := job.ExportEnv(&config); err != nil {

+		return err.Error()

+	}

 	if config.Memory != 0 && config.Memory < 524288 {

-		return "", nil, fmt.Errorf("Memory limit must be given in bytes (minimum 524288 bytes)")

+		return "Memory limit must be given in bytes (minimum 524288 bytes)"

 	}

-

 	if config.Memory > 0 && !srv.runtime.capabilities.MemoryLimit {

 		config.Memory = 0

 	}

-

 	if config.Memory > 0 && !srv.runtime.capabilities.SwapLimit {

 		config.MemorySwap = -1

 	}

-	container, buildWarnings, err := srv.runtime.Create(config, name)

+	container, buildWarnings, err := srv.runtime.Create(&config, name)

 	if err != nil {

 		if srv.runtime.graph.IsNotExist(err) {

-

 			_, tag := utils.ParseRepositoryTag(config.Image)

 			if tag == "" {

 				tag = DEFAULTTAG

 			}

-

-			return "", nil, fmt.Errorf("No such image: %s (tag: %s)", config.Image, tag)

+			return fmt.Sprintf("No such image: %s (tag: %s)", config.Image, tag)

 		}

-		return "", nil, err

+		return err.Error()

 	}

 	srv.LogEvent("create", container.ShortID(), srv.runtime.repositories.ImageName(container.Image))

-	return container.ShortID(), buildWarnings, nil

+	job.Printf("%s\n", container.ShortID())

+	for _, warning := range buildWarnings {

+		job.Errorf("%s\n", warning)

+	}

+	return "0"

 }

 func (srv *Server) ContainerRestart(name string, t int) error {

@@ -79,20 +79,17 @@ func TestContainerTagImageDelete(t *testing.T) {

 }

 func TestCreateRm(t *testing.T) {

-	runtime := mkRuntime(t)

+	eng := NewTestEngine(t)

+	srv := mkServerFromEngine(eng, t)

+	runtime := srv.runtime

 	defer nuke(runtime)

-	srv := &Server{runtime: runtime}

-

 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil)

 	if err != nil {

 		t.Fatal(err)

 	}

-	id, _, err := srv.ContainerCreate(config, "")

-	if err != nil {

-		t.Fatal(err)

-	}

+	id := createTestContainer(eng, config, t)

 	if len(runtime.List()) != 1 {

 		t.Errorf("Expected 1 container, %v found", len(runtime.List()))

@@ -120,10 +117,7 @@ func TestCreateRmVolumes(t *testing.T) {

 		t.Fatal(err)

 	}

-	id, _, err := srv.ContainerCreate(config, "")

-	if err != nil {

-		t.Fatal(err)

-	}

+	id := createTestContainer(eng, config, t)

 	if len(runtime.List()) != 1 {

 		t.Errorf("Expected 1 container, %v found", len(runtime.List()))

@@ -152,20 +146,17 @@ func TestCreateRmVolumes(t *testing.T) {

 }

 func TestCommit(t *testing.T) {

-	runtime := mkRuntime(t)

+	eng := NewTestEngine(t)

+	srv := mkServerFromEngine(eng, t)

+	runtime := srv.runtime

 	defer nuke(runtime)

-	srv := &Server{runtime: runtime}

-

 	config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "/bin/cat"}, nil)

 	if err != nil {

 		t.Fatal(err)

 	}

-	id, _, err := srv.ContainerCreate(config, "")

-	if err != nil {

-		t.Fatal(err)

-	}

+	id := createTestContainer(eng, config, t)

 	if _, err := srv.ContainerCommit(id, "testrepo", "testtag", "", "", config); err != nil {

 		t.Fatal(err)

@@ -183,10 +174,7 @@ func TestCreateStartRestartStopStartKillRm(t *testing.T) {

 		t.Fatal(err)

 	}

-	id, _, err := srv.ContainerCreate(config, "")

-	if err != nil {

-		t.Fatal(err)

-	}

+	id := createTestContainer(eng, config, t)

 	if len(runtime.List()) != 1 {

 		t.Errorf("Expected 1 container, %v found", len(runtime.List()))

@@ -232,22 +220,22 @@ func TestCreateStartRestartStopStartKillRm(t *testing.T) {

 }

 func TestRunWithTooLowMemoryLimit(t *testing.T) {

-	runtime := mkRuntime(t)

+	eng := NewTestEngine(t)

+	srv := mkServerFromEngine(eng, t)

+	runtime := srv.runtime

 	defer nuke(runtime)

 	// Try to create a container with a memory limit of 1 byte less than the minimum allowed limit.

-	if _, _, err := (*Server).ContainerCreate(&Server{runtime: runtime},

-		&Config{

-			Image:     GetTestImage(runtime).ID,

-			Memory:    524287,

-			CpuShares: 1000,

-			Cmd:       []string{"/bin/cat"},

-		},

-		"",

-	); err == nil {

+	job := eng.Job("create")

+	job.Setenv("Image", GetTestImage(runtime).ID)

+	job.Setenv("Memory", "524287")

+	job.Setenv("CpuShares", "1000")

+	job.SetenvList("Cmd", []string{"/bin/cat"})

+	var id string

+	job.StdoutParseString(&id)

+	if err := job.Run(); err == nil {

 		t.Errorf("Memory limit is smaller than the allowed limit. Container creation should've failed!")

 	}

-

 }

 func TestContainerTop(t *testing.T) {

@@ -411,10 +399,7 @@ func TestRmi(t *testing.T) {

 		t.Fatal(err)

 	}

-	containerID, _, err := srv.ContainerCreate(config, "")

-	if err != nil {

-		t.Fatal(err)

-	}

+	containerID := createTestContainer(eng, config, t)

 	//To remove

 	job := eng.Job("start", containerID)

@@ -435,10 +420,7 @@ func TestRmi(t *testing.T) {

 		t.Fatal(err)

 	}

-	containerID, _, err = srv.ContainerCreate(config, "")

-	if err != nil {

-		t.Fatal(err)

-	}

+	containerID = createTestContainer(eng, config, t)

 	//To remove

 	job = eng.Job("start", containerID)

@@ -38,6 +38,22 @@ func mkRuntime(f utils.Fataler) *Runtime {

 	return r

 }

+func createNamedTestContainer(eng *engine.Engine, config *Config, f utils.Fataler, name string) (shortId string) {

+	job := eng.Job("create", name)

+	if err := job.ImportEnv(config); err != nil {

+		f.Fatal(err)

+	}

+	job.StdoutParseString(&shortId)

+	if err := job.Run(); err != nil {

+		f.Fatal(err)

+	}

+	return

+}

+

+func createTestContainer(eng *engine.Engine, config *Config, f utils.Fataler) (shortId string) {

+	return createNamedTestContainer(eng, config, f, "")

+}

+

 func mkServerFromEngine(eng *engine.Engine, t utils.Fataler) *Server {

 	iSrv := eng.Hack_GetGlobalVar("httpapi.server")

 	if iSrv == nil {