tools/fuzz/instance_test.go - fuchsia - Git at Google

 // Copyright 2020 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package fuzz

 import (
 	"bytes"
 	"os"
 	"path/filepath"
 	"reflect"
 	"strings"
 	"testing"
 	"time"

 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 )

 func newTestInstance() *BaseInstance {
 	build, _ := newMockBuild()
 	return &BaseInstance{Build: build, reconnectInterval: defaultReconnectInterval}
 }

 func TestInstanceHandle(t *testing.T) {
 	// Instance loading automatically loads the build, so we need to stub it out
 	realNewBuild := NewBuild
 	NewBuild = newMockBuild
 	defer func() { NewBuild = realNewBuild }()

 	instance := newTestInstance()
 	instance.Launcher = &QemuLauncher{Pid: 404, TmpDir: "/some/dir"}
 	instance.Connector = NewSSHConnector(nil, "somehost", 123, "keyfile", "/tmp/path")

 	handle, err := instance.Handle()
 	if err != nil {
 		t.Fatalf("error creating handle: %s", err)
 	}
 	defer handle.Release()

 	handle2, err := instance.Handle()
 	if handle.Serialize() != handle2.Serialize() {
 		handle2.Release()
 		t.Fatalf("same instance returned different handles: %q, %q", handle, handle2)
 	}

 	// Note: we don't serialize here because that is covered by handle tests

 	reloadedInstance, err := loadInstanceFromHandle(handle, true)
 	if err != nil {
 		t.Fatalf("error loading instance from handle: %s", err)
 	}

 	got, ok := reloadedInstance.(*BaseInstance)
 	if !ok {
 		t.Fatalf("incorrect instance type")
 	}

 	if diff := cmp.Diff(instance, got, cmpopts.IgnoreUnexported(BaseInstance{},
 		SSHConnector{}, QemuLauncher{}, mockBuild{})); diff != "" {
 		t.Fatalf("incorrect data in reloaded instance (-want +got):\n%s", diff)
 	}

 	// Ensure that handle is released and invalid upon stopping
 	if err := instance.Stop(); err != nil {
 		t.Fatalf("error stopping instance: %s", err)
 	}

 	reloadedInstance, err = loadInstanceFromHandle(handle, true)
 	if err == nil {
 		t.Fatalf("unexpected success reloading instance from released handle: %q", handle)
 	}
 }

 func TestInstanceLoadHandleFromOldVersion(t *testing.T) {
 	// Instance loading automatically loads the build, so we need to stub it out
 	realNewBuild := NewBuild
 	NewBuild = newMockBuild
 	defer func() { NewBuild = realNewBuild }()

 	// Create a handle file mimicking an earlier version. We assume for
 	// simplicity's sake that old versions of a given Connector type will
 	// always be a subset of the new type.
 	json := `{"LauncherType": "QemuLauncher", "Launcher": {"Pid": 123}}`
 	handlePath := filepath.Join(t.TempDir(), "some.handle")
 	if err := os.WriteFile(handlePath, []byte(json), 0o600); err != nil {
 		t.Fatalf("error writing handle: %s", err)
 	}

 	handle := Handle(handlePath)

 	if _, err := loadInstanceFromHandle(handle, true); err == nil {
 		t.Fatalf("unexpectedly succeeded loading incomplete instance")
 	}

 	instance, err := loadInstanceFromHandle(handle, false)
 	if err != nil {
 		t.Fatalf("error loading instance from handle: %s", err)
 	}

 	if instance.(*BaseInstance).Launcher.(*QemuLauncher).Pid != 123 {
 		t.Fatalf("incorrect launcher pid found: %+v", instance)
 	}
 }

 func TestInstanceRepeatedStart(t *testing.T) {
 	i := newTestInstance()
 	i.Launcher = NewMockLauncher(t)

 	if err := i.Start(); err != nil {
 		t.Fatalf("Error starting instance: %s", err)
 	}

 	if err := i.Start(); err == nil {
 		t.Fatalf("Expected error starting already-running instance but succeeded")
 	}
 }

 func TestInstanceStartWithLauncherFailure(t *testing.T) {
 	i := newTestInstance()
 	launcher := NewMockLauncher(t)
 	launcher.shouldFailToStart = true
 	i.Launcher = launcher

 	if err := i.Start(); err == nil {
 		t.Fatalf("expected launcher failure but succeeded")
 	}
 }

 func TestInstanceStartWithLauncherEarlyExit(t *testing.T) {
 	i := newTestInstance()
 	// Only the first connection will fail, but no retries should be made
 	// because the launcher will have died.
 	launcher := NewMockLauncher(t)
 	launcher.shouldFailToConnectCount = 1
 	launcher.shouldExitEarly = true
 	i.Launcher = launcher

 	if err := i.Start(); err == nil {
 		t.Fatalf("expected launcher failure but succeeded")
 	}

 	if running, _ := i.Launcher.IsRunning(); running {
 		t.Fatalf("expected launcher to have been killed, but it is running")
 	}

 	if !i.Connector.(*mockConnector).CleanedUp {
 		t.Fatalf("connector not cleaned up")
 	}
 }

 func TestInstanceStartWithTemporaryConnectorFailure(t *testing.T) {
 	i := newTestInstance()
 	launcher := NewMockLauncher(t)
 	launcher.shouldFailToConnectCount = maxInitialConnectAttempts - 1
 	i.Launcher = launcher
 	i.reconnectInterval = 1 * time.Millisecond

 	if err := i.Start(); err != nil {
 		t.Fatalf("Expected connector to succeed after reconnection attempt")
 	}

 	if err := i.Stop(); err != nil {
 		t.Fatalf("Error stopping instance: %s", err)
 	}

 	if running, _ := i.Launcher.IsRunning(); running {
 		t.Fatalf("expected launcher to have been killed, but it is running")
 	}

 	if !i.Connector.(*mockConnector).CleanedUp {
 		t.Fatalf("connector not cleaned up")
 	}
 }

 func TestInstanceStartWithPermanentConnectorFailure(t *testing.T) {
 	i := newTestInstance()
 	launcher := NewMockLauncher(t)
 	launcher.shouldFailToConnectCount = maxInitialConnectAttempts
 	i.Launcher = launcher
 	i.reconnectInterval = 1 * time.Millisecond

 	if err := i.Start(); err == nil {
 		t.Fatalf("Expected connector failure but succeeded")
 	}

 	if running, _ := i.Launcher.IsRunning(); running {
 		t.Fatalf("expected launcher to have been killed, but it is running")
 	}

 	if !i.Connector.(*mockConnector).CleanedUp {
 		t.Fatalf("connector not cleaned up")
 	}
 }

 func TestInstanceStartWithTemporaryCommandFailure(t *testing.T) {
 	i := newTestInstance()
 	launcher := NewMockLauncher(t)
 	launcher.shouldFailToConnectCount = maxInitialConnectAttempts - 1
 	i.Launcher = launcher
 	i.reconnectInterval = 1 * time.Millisecond

 	if err := i.Start(); err != nil {
 		t.Fatalf("Expected to succeed after command re-execution attempt")
 	}

 	if err := i.Stop(); err != nil {
 		t.Fatalf("Error stopping instance: %s", err)
 	}

 	if running, _ := i.Launcher.IsRunning(); running {
 		t.Fatalf("expected launcher to have been killed, but it is running")
 	}

 	if !i.Connector.(*mockConnector).CleanedUp {
 		t.Fatalf("connector not cleaned up")
 	}
 }

 func TestInstanceStartWithPermanentCommandFailure(t *testing.T) {
 	i := newTestInstance()
 	launcher := NewMockLauncher(t)
 	launcher.shouldFailToConnectCount = maxInitialConnectAttempts + 1
 	i.Launcher = launcher
 	i.reconnectInterval = 1 * time.Millisecond

 	if err := i.Start(); err == nil {
 		t.Fatalf("Expected command execution failure but succeeded")
 	}

 	if running, _ := i.Launcher.IsRunning(); running {
 		t.Fatalf("expected launcher to have been killed, but it is running")
 	}

 	if !i.Connector.(*mockConnector).CleanedUp {
 		t.Fatalf("connector not cleaned up")
 	}
 }

 func TestInstance(t *testing.T) {
 	i := newTestInstance()
 	i.Launcher = NewMockLauncher(t)

 	if err := i.Start(); err != nil {
 		t.Fatalf("Error starting instance: %s", err)
 	}

 	fuzzers := i.ListFuzzers()

 	if !reflect.DeepEqual(fuzzers, []string{"foo/bar", "fail/nopid", "fail/notfound",
 		"cff/fuzzer", "cff/broken"}) {
 		t.Fatalf("incorrect fuzzer list: %v", fuzzers)
 	}

 	var outBuf bytes.Buffer
 	if err := i.RunFuzzer(&outBuf, "foo/bar", "", "arg1", "arg2"); err != nil {
 		t.Fatalf("Error running fuzzer: %s", err)
 	}
 	out := outBuf.String()

 	// Just a basic check here, more are done in fuzzer_tests
 	if !strings.Contains(out, "fuchsia-pkg://fuchsia.com/foo#meta/bar.cm") {
 		t.Fatalf("fuzzer output missing package: %q", out)
 	}

 	if err := i.RunFuzzer(&outBuf, "invalid/fuzzer", ""); err == nil {
 		t.Fatalf("expected error when running invalid fuzzer")
 	}

 	tmpDir := t.TempDir()
 	remotePath := "data/path/to/remoteFile"
 	if err := i.Get("foo/bar", remotePath, tmpDir); err != nil {
 		t.Fatalf("Error getting from instance: %s", err)
 	}

 	expected := []transferCmd{
 		{"/tmp/fuzz_ctl/fuchsia.com/foo/bar/path/to/remoteFile",
 			tmpDir}}
 	got := i.Connector.(*mockConnector).PathsGot
 	if !reflect.DeepEqual(got, expected) {
 		t.Fatalf("incorrect file get list: %v", got)
 	}

 	tmpFile := filepath.Join(tmpDir, "secrets.ini")
 	if err := os.WriteFile(tmpFile, []byte("shh"), 0o600); err != nil {
 		t.Fatalf("error writing file: %s", err)
 	}
 	remotePath = "data/path/to/otherFile"
 	if err := i.Put("foo/bar", tmpFile, remotePath); err != nil {
 		t.Fatalf("Error putting to instance: %s", err)
 	}

 	expected = []transferCmd{{tmpFile,
 		"/tmp/fuzz_ctl/fuchsia.com/foo/bar/path/to/otherFile"}}
 	got = i.Connector.(*mockConnector).PathsPut
 	if !reflect.DeepEqual(got, expected) {
 		t.Fatalf("incorrect file put list: %v", got)
 	}

 	var logBuf bytes.Buffer
 	if err := i.GetLogs(&logBuf); err != nil {
 		t.Fatalf("error getting instance logs: %s", err)
 	}

 	log := logBuf.String()
 	if log != "system log\n" {
 		t.Fatalf("unexpected instance log: %q", log)
 	}

 	if err := i.Stop(); err != nil {
 		t.Fatalf("Error stopping instance: %s", err)
 	}

 	if running, _ := i.Launcher.IsRunning(); running {
 		t.Fatalf("expected launcher to have been killed, but it is running")
 	}

 	if !i.Connector.(*mockConnector).CleanedUp {
 		t.Fatalf("Connector not cleaned up when instance stopped")
 	}
 }

 func TestInstanceRunFuzzerWithArtifactFetch(t *testing.T) {
 	i := newTestInstance()
 	i.Launcher = NewMockLauncher(t)

 	if err := i.Start(); err != nil {
 		t.Fatalf("Error starting instance: %s", err)
 	}

 	hostArtifactDir := t.TempDir()
 	var outBuf bytes.Buffer
 	args := []string{"-artifact_prefix=data/wow/x", "data/corpus"}
 	if err := i.RunFuzzer(&outBuf, "foo/bar", hostArtifactDir, args...); err != nil {
 		t.Fatalf("Error running fuzzer: %s", err)
 	}

 	out := outBuf.String()
 	if !strings.Contains(out, filepath.Join(hostArtifactDir, "xcrash-1312")) {
 		t.Fatalf("fuzzer output missing host artifact path: %q", out)
 	}

 	expected := []transferCmd{{"/tmp/fuzz_ctl/fuchsia.com/foo/bar/wow/xcrash-1312",
 		hostArtifactDir}}
 	got := i.Connector.(*mockConnector).PathsGot
 	if !reflect.DeepEqual(got, expected) {
 		t.Fatalf("incorrect file get list: %v", got)
 	}

 	if err := i.Stop(); err != nil {
 		t.Fatalf("Error stopping instance: %s", err)
 	}

 	if running, _ := i.Launcher.IsRunning(); running {
 		t.Fatalf("expected launcher to have been killed, but it is running")
 	}
 }
	// Copyright 2020 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package fuzz

	import (
	"bytes"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	)

	func newTestInstance() *BaseInstance {
	build, _ := newMockBuild()
	return &BaseInstance{Build: build, reconnectInterval: defaultReconnectInterval}
	}

	func TestInstanceHandle(t *testing.T) {
	// Instance loading automatically loads the build, so we need to stub it out
	realNewBuild := NewBuild
	NewBuild = newMockBuild
	defer func() { NewBuild = realNewBuild }()

	instance := newTestInstance()
	instance.Launcher = &QemuLauncher{Pid: 404, TmpDir: "/some/dir"}
	instance.Connector = NewSSHConnector(nil, "somehost", 123, "keyfile", "/tmp/path")

	handle, err := instance.Handle()
	if err != nil {
	t.Fatalf("error creating handle: %s", err)
	}
	defer handle.Release()

	handle2, err := instance.Handle()
	if handle.Serialize() != handle2.Serialize() {
	handle2.Release()
	t.Fatalf("same instance returned different handles: %q, %q", handle, handle2)
	}

	// Note: we don't serialize here because that is covered by handle tests

	reloadedInstance, err := loadInstanceFromHandle(handle, true)
	if err != nil {
	t.Fatalf("error loading instance from handle: %s", err)
	}

	got, ok := reloadedInstance.(*BaseInstance)
	if !ok {
	t.Fatalf("incorrect instance type")
	}

	if diff := cmp.Diff(instance, got, cmpopts.IgnoreUnexported(BaseInstance{},
	SSHConnector{}, QemuLauncher{}, mockBuild{})); diff != "" {
	t.Fatalf("incorrect data in reloaded instance (-want +got):\n%s", diff)
	}

	// Ensure that handle is released and invalid upon stopping
	if err := instance.Stop(); err != nil {
	t.Fatalf("error stopping instance: %s", err)
	}

	reloadedInstance, err = loadInstanceFromHandle(handle, true)
	if err == nil {
	t.Fatalf("unexpected success reloading instance from released handle: %q", handle)
	}
	}

	func TestInstanceLoadHandleFromOldVersion(t *testing.T) {
	// Instance loading automatically loads the build, so we need to stub it out
	realNewBuild := NewBuild
	NewBuild = newMockBuild
	defer func() { NewBuild = realNewBuild }()

	// Create a handle file mimicking an earlier version. We assume for
	// simplicity's sake that old versions of a given Connector type will
	// always be a subset of the new type.
	json := `{"LauncherType": "QemuLauncher", "Launcher": {"Pid": 123}}`
	handlePath := filepath.Join(t.TempDir(), "some.handle")
	if err := os.WriteFile(handlePath, []byte(json), 0o600); err != nil {
	t.Fatalf("error writing handle: %s", err)
	}

	handle := Handle(handlePath)

	if _, err := loadInstanceFromHandle(handle, true); err == nil {
	t.Fatalf("unexpectedly succeeded loading incomplete instance")
	}

	instance, err := loadInstanceFromHandle(handle, false)
	if err != nil {
	t.Fatalf("error loading instance from handle: %s", err)
	}

	if instance.(BaseInstance).Launcher.(QemuLauncher).Pid != 123 {
	t.Fatalf("incorrect launcher pid found: %+v", instance)
	}
	}

	func TestInstanceRepeatedStart(t *testing.T) {
	i := newTestInstance()
	i.Launcher = NewMockLauncher(t)

	if err := i.Start(); err != nil {
	t.Fatalf("Error starting instance: %s", err)
	}

	if err := i.Start(); err == nil {
	t.Fatalf("Expected error starting already-running instance but succeeded")
	}
	}

	func TestInstanceStartWithLauncherFailure(t *testing.T) {
	i := newTestInstance()
	launcher := NewMockLauncher(t)
	launcher.shouldFailToStart = true
	i.Launcher = launcher

	if err := i.Start(); err == nil {
	t.Fatalf("expected launcher failure but succeeded")
	}
	}

	func TestInstanceStartWithLauncherEarlyExit(t *testing.T) {
	i := newTestInstance()
	// Only the first connection will fail, but no retries should be made
	// because the launcher will have died.
	launcher := NewMockLauncher(t)
	launcher.shouldFailToConnectCount = 1
	launcher.shouldExitEarly = true
	i.Launcher = launcher

	if err := i.Start(); err == nil {
	t.Fatalf("expected launcher failure but succeeded")
	}

	if running, _ := i.Launcher.IsRunning(); running {
	t.Fatalf("expected launcher to have been killed, but it is running")
	}

	if !i.Connector.(*mockConnector).CleanedUp {
	t.Fatalf("connector not cleaned up")
	}
	}

	func TestInstanceStartWithTemporaryConnectorFailure(t *testing.T) {
	i := newTestInstance()
	launcher := NewMockLauncher(t)
	launcher.shouldFailToConnectCount = maxInitialConnectAttempts - 1
	i.Launcher = launcher
	i.reconnectInterval = 1 * time.Millisecond

	if err := i.Start(); err != nil {
	t.Fatalf("Expected connector to succeed after reconnection attempt")
	}

	if err := i.Stop(); err != nil {
	t.Fatalf("Error stopping instance: %s", err)
	}

	if running, _ := i.Launcher.IsRunning(); running {
	t.Fatalf("expected launcher to have been killed, but it is running")
	}

	if !i.Connector.(*mockConnector).CleanedUp {
	t.Fatalf("connector not cleaned up")
	}
	}

	func TestInstanceStartWithPermanentConnectorFailure(t *testing.T) {
	i := newTestInstance()
	launcher := NewMockLauncher(t)
	launcher.shouldFailToConnectCount = maxInitialConnectAttempts
	i.Launcher = launcher
	i.reconnectInterval = 1 * time.Millisecond

	if err := i.Start(); err == nil {
	t.Fatalf("Expected connector failure but succeeded")
	}

	if running, _ := i.Launcher.IsRunning(); running {
	t.Fatalf("expected launcher to have been killed, but it is running")
	}

	if !i.Connector.(*mockConnector).CleanedUp {
	t.Fatalf("connector not cleaned up")
	}
	}

	func TestInstanceStartWithTemporaryCommandFailure(t *testing.T) {
	i := newTestInstance()
	launcher := NewMockLauncher(t)
	launcher.shouldFailToConnectCount = maxInitialConnectAttempts - 1
	i.Launcher = launcher
	i.reconnectInterval = 1 * time.Millisecond

	if err := i.Start(); err != nil {
	t.Fatalf("Expected to succeed after command re-execution attempt")
	}

	if err := i.Stop(); err != nil {
	t.Fatalf("Error stopping instance: %s", err)
	}

	if running, _ := i.Launcher.IsRunning(); running {
	t.Fatalf("expected launcher to have been killed, but it is running")
	}

	if !i.Connector.(*mockConnector).CleanedUp {
	t.Fatalf("connector not cleaned up")
	}
	}

	func TestInstanceStartWithPermanentCommandFailure(t *testing.T) {
	i := newTestInstance()
	launcher := NewMockLauncher(t)
	launcher.shouldFailToConnectCount = maxInitialConnectAttempts + 1
	i.Launcher = launcher
	i.reconnectInterval = 1 * time.Millisecond

	if err := i.Start(); err == nil {
	t.Fatalf("Expected command execution failure but succeeded")
	}

	if running, _ := i.Launcher.IsRunning(); running {
	t.Fatalf("expected launcher to have been killed, but it is running")
	}

	if !i.Connector.(*mockConnector).CleanedUp {
	t.Fatalf("connector not cleaned up")
	}
	}

	func TestInstance(t *testing.T) {
	i := newTestInstance()
	i.Launcher = NewMockLauncher(t)

	if err := i.Start(); err != nil {
	t.Fatalf("Error starting instance: %s", err)
	}

	fuzzers := i.ListFuzzers()

	if !reflect.DeepEqual(fuzzers, []string{"foo/bar", "fail/nopid", "fail/notfound",
	"cff/fuzzer", "cff/broken"}) {
	t.Fatalf("incorrect fuzzer list: %v", fuzzers)
	}

	var outBuf bytes.Buffer
	if err := i.RunFuzzer(&outBuf, "foo/bar", "", "arg1", "arg2"); err != nil {
	t.Fatalf("Error running fuzzer: %s", err)
	}
	out := outBuf.String()

	// Just a basic check here, more are done in fuzzer_tests
	if !strings.Contains(out, "fuchsia-pkg://fuchsia.com/foo#meta/bar.cm") {
	t.Fatalf("fuzzer output missing package: %q", out)
	}

	if err := i.RunFuzzer(&outBuf, "invalid/fuzzer", ""); err == nil {
	t.Fatalf("expected error when running invalid fuzzer")
	}

	tmpDir := t.TempDir()
	remotePath := "data/path/to/remoteFile"
	if err := i.Get("foo/bar", remotePath, tmpDir); err != nil {
	t.Fatalf("Error getting from instance: %s", err)
	}

	expected := []transferCmd{
	{"/tmp/fuzz_ctl/fuchsia.com/foo/bar/path/to/remoteFile",
	tmpDir}}
	got := i.Connector.(*mockConnector).PathsGot
	if !reflect.DeepEqual(got, expected) {
	t.Fatalf("incorrect file get list: %v", got)
	}

	tmpFile := filepath.Join(tmpDir, "secrets.ini")
	if err := os.WriteFile(tmpFile, []byte("shh"), 0o600); err != nil {
	t.Fatalf("error writing file: %s", err)
	}
	remotePath = "data/path/to/otherFile"
	if err := i.Put("foo/bar", tmpFile, remotePath); err != nil {
	t.Fatalf("Error putting to instance: %s", err)
	}

	expected = []transferCmd{{tmpFile,
	"/tmp/fuzz_ctl/fuchsia.com/foo/bar/path/to/otherFile"}}
	got = i.Connector.(*mockConnector).PathsPut
	if !reflect.DeepEqual(got, expected) {
	t.Fatalf("incorrect file put list: %v", got)
	}

	var logBuf bytes.Buffer
	if err := i.GetLogs(&logBuf); err != nil {
	t.Fatalf("error getting instance logs: %s", err)
	}

	log := logBuf.String()
	if log != "system log\n" {
	t.Fatalf("unexpected instance log: %q", log)
	}

	if err := i.Stop(); err != nil {
	t.Fatalf("Error stopping instance: %s", err)
	}

	if running, _ := i.Launcher.IsRunning(); running {
	t.Fatalf("expected launcher to have been killed, but it is running")
	}

	if !i.Connector.(*mockConnector).CleanedUp {
	t.Fatalf("Connector not cleaned up when instance stopped")
	}
	}

	func TestInstanceRunFuzzerWithArtifactFetch(t *testing.T) {
	i := newTestInstance()
	i.Launcher = NewMockLauncher(t)

	if err := i.Start(); err != nil {
	t.Fatalf("Error starting instance: %s", err)
	}

	hostArtifactDir := t.TempDir()
	var outBuf bytes.Buffer
	args := []string{"-artifact_prefix=data/wow/x", "data/corpus"}
	if err := i.RunFuzzer(&outBuf, "foo/bar", hostArtifactDir, args...); err != nil {
	t.Fatalf("Error running fuzzer: %s", err)
	}

	out := outBuf.String()
	if !strings.Contains(out, filepath.Join(hostArtifactDir, "xcrash-1312")) {
	t.Fatalf("fuzzer output missing host artifact path: %q", out)
	}

	expected := []transferCmd{{"/tmp/fuzz_ctl/fuchsia.com/foo/bar/wow/xcrash-1312",
	hostArtifactDir}}
	got := i.Connector.(*mockConnector).PathsGot
	if !reflect.DeepEqual(got, expected) {
	t.Fatalf("incorrect file get list: %v", got)
	}

	if err := i.Stop(); err != nil {
	t.Fatalf("Error stopping instance: %s", err)
	}

	if running, _ := i.Launcher.IsRunning(); running {
	t.Fatalf("expected launcher to have been killed, but it is running")
	}
	}