@@ -3,285 +3,35 @@

 package devmapper

 import (

+	"github.com/dotcloud/docker/daemon/graphdriver/graphtest"

 	"testing"

 )

-func TestTaskCreate(t *testing.T) {

-	t.Skip("FIXME: not a unit test")

-	// Test success

-	taskCreate(t, DeviceInfo)

-

-	// Test Failure

-	DmTaskCreate = dmTaskCreateFail

-	defer func() { DmTaskCreate = dmTaskCreateFct }()

-	if task := TaskCreate(-1); task != nil {

-		t.Fatalf("An error should have occured while creating an invalid task.")

-	}

-}

-

-func TestTaskRun(t *testing.T) {

-	t.Skip("FIXME: not a unit test")

-	task := taskCreate(t, DeviceInfo)

-

-	// Test success

-	// Perform the RUN

-	if err := task.Run(); err != nil {

-		t.Fatal(err)

-	}

-	// Make sure we don't have error with GetInfo

-	if _, err := task.GetInfo(); err != nil {

-		t.Fatal(err)

-	}

-

-	// Test failure

-	DmTaskRun = dmTaskRunFail

-	defer func() { DmTaskRun = dmTaskRunFct }()

-

-	task = taskCreate(t, DeviceInfo)

-	// Perform the RUN

-	if err := task.Run(); err != ErrTaskRun {

-		t.Fatalf("An error should have occured while running task.")

-	}

-	// Make sure GetInfo also fails

-	if _, err := task.GetInfo(); err != ErrTaskGetInfo {

-		t.Fatalf("GetInfo should fail if task.Run() failed.")

-	}

-}

-

-func TestTaskSetName(t *testing.T) {

-	t.Skip("FIXME: not a unit test")

-	task := taskCreate(t, DeviceInfo)

-

-	// Test success

-	if err := task.SetName("test"); err != nil {

-		t.Fatal(err)

-	}

-

-	// Test failure

-	DmTaskSetName = dmTaskSetNameFail

-	defer func() { DmTaskSetName = dmTaskSetNameFct }()

-

-	if err := task.SetName("test"); err != ErrTaskSetName {

-		t.Fatalf("An error should have occured while runnign SetName.")

-	}

-}

-

-func TestTaskSetMessage(t *testing.T) {

-	t.Skip("FIXME: not a unit test")

-	task := taskCreate(t, DeviceInfo)

-

-	// Test success

-	if err := task.SetMessage("test"); err != nil {

-		t.Fatal(err)

-	}

-

-	// Test failure

-	DmTaskSetMessage = dmTaskSetMessageFail

-	defer func() { DmTaskSetMessage = dmTaskSetMessageFct }()

-

-	if err := task.SetMessage("test"); err != ErrTaskSetMessage {

-		t.Fatalf("An error should have occured while runnign SetMessage.")

-	}

-}

-

-func TestTaskSetSector(t *testing.T) {

-	t.Skip("FIXME: not a unit test")

-	task := taskCreate(t, DeviceInfo)

-

-	// Test success

-	if err := task.SetSector(128); err != nil {

-		t.Fatal(err)

-	}

-

-	DmTaskSetSector = dmTaskSetSectorFail

-	defer func() { DmTaskSetSector = dmTaskSetSectorFct }()

-

-	// Test failure

-	if err := task.SetSector(0); err != ErrTaskSetSector {

-		t.Fatalf("An error should have occured while running SetSector.")

-	}

-}

-

-func TestTaskSetCookie(t *testing.T) {

-	t.Skip("FIXME: not a unit test")

-	var (

-		cookie uint = 0

-		task        = taskCreate(t, DeviceInfo)

-	)

-

-	// Test success

-	if err := task.SetCookie(&cookie, 0); err != nil {

-		t.Fatal(err)

-	}

-

-	// Test failure

-	if err := task.SetCookie(nil, 0); err != ErrNilCookie {

-		t.Fatalf("An error should have occured while running SetCookie with nil cookie.")

-	}

-

-	DmTaskSetCookie = dmTaskSetCookieFail

-	defer func() { DmTaskSetCookie = dmTaskSetCookieFct }()

-

-	if err := task.SetCookie(&cookie, 0); err != ErrTaskSetCookie {

-		t.Fatalf("An error should have occured while running SetCookie.")

-	}

-}

-

-func TestTaskSetAddNode(t *testing.T) {

-	t.Skip("FIXME: not a unit test")

-	task := taskCreate(t, DeviceInfo)

-

-	// Test success

-	if err := task.SetAddNode(0); err != nil {

-		t.Fatal(err)

-	}

-

-	// Test failure

-	if err := task.SetAddNode(-1); err != ErrInvalidAddNode {

-		t.Fatalf("An error should have occured running SetAddNode with wrong node.")

-	}

-

-	DmTaskSetAddNode = dmTaskSetAddNodeFail

-	defer func() { DmTaskSetAddNode = dmTaskSetAddNodeFct }()

-

-	if err := task.SetAddNode(0); err != ErrTaskSetAddNode {

-		t.Fatalf("An error should have occured running SetAddNode.")

-	}

-}

-

-func TestTaskSetRo(t *testing.T) {

-	t.Skip("FIXME: not a unit test")

-	task := taskCreate(t, DeviceInfo)

-

-	// Test success

-	if err := task.SetRo(); err != nil {

-		t.Fatal(err)

-	}

-

-	// Test failure

-	DmTaskSetRo = dmTaskSetRoFail

-	defer func() { DmTaskSetRo = dmTaskSetRoFct }()

-

-	if err := task.SetRo(); err != ErrTaskSetRo {

-		t.Fatalf("An error should have occured running SetRo.")

-	}

-}

-

-func TestTaskAddTarget(t *testing.T) {

-	t.Skip("FIXME: not a unit test")

-	task := taskCreate(t, DeviceInfo)

-

-	// Test success

-	if err := task.AddTarget(0, 128, "thinp", ""); err != nil {

-		t.Fatal(err)

-	}

-

-	// Test failure

-	DmTaskAddTarget = dmTaskAddTargetFail

-	defer func() { DmTaskAddTarget = dmTaskAddTargetFct }()

-

-	if err := task.AddTarget(0, 128, "thinp", ""); err != ErrTaskAddTarget {

-		t.Fatalf("An error should have occured running AddTarget.")

-	}

-}

-

-// func TestTaskGetInfo(t *testing.T) {

-// 	task := taskCreate(t, DeviceInfo)

-

-// 	// Test success

-// 	if _, err := task.GetInfo(); err != nil {

-// 		t.Fatal(err)

-// 	}

-

-// 	// Test failure

-// 	DmTaskGetInfo = dmTaskGetInfoFail

-// 	defer func() { DmTaskGetInfo = dmTaskGetInfoFct }()

-

-// 	if _, err := task.GetInfo(); err != ErrTaskGetInfo {

-// 		t.Fatalf("An error should have occured running GetInfo.")

-// 	}

-// }

-

-// func TestTaskGetNextTarget(t *testing.T) {

-// 	task := taskCreate(t, DeviceInfo)

-

-// 	if next, _, _, _, _ := task.GetNextTarget(0); next == 0 {

-// 		t.Fatalf("The next target should not be 0.")

-// 	}

-// }

-

-/// Utils

-func taskCreate(t *testing.T, taskType TaskType) *Task {

-	task := TaskCreate(taskType)

-	if task == nil {

-		t.Fatalf("Error creating task")

-	}

-	return task

-}

-

-/// Failure function replacement

-func dmTaskCreateFail(t int) *CDmTask {

-	return nil

-}

-

-func dmTaskRunFail(task *CDmTask) int {

-	return -1

-}

-

-func dmTaskSetNameFail(task *CDmTask, name string) int {

-	return -1

-}

-

-func dmTaskSetMessageFail(task *CDmTask, message string) int {

-	return -1

-}

-

-func dmTaskSetSectorFail(task *CDmTask, sector uint64) int {

-	return -1

-}

-

-func dmTaskSetCookieFail(task *CDmTask, cookie *uint, flags uint16) int {

-	return -1

-}

-

-func dmTaskSetAddNodeFail(task *CDmTask, addNode AddNodeType) int {

-	return -1

-}

-

-func dmTaskSetRoFail(task *CDmTask) int {

-	return -1

-}

-

-func dmTaskAddTargetFail(task *CDmTask,

-	start, size uint64, ttype, params string) int {

-	return -1

-}

-

-func dmTaskGetInfoFail(task *CDmTask, info *Info) int {

-	return -1

-}

-

-func dmGetNextTargetFail(task *CDmTask, next uintptr, start, length *uint64,

-	target, params *string) uintptr {

-	return 0

+func init() {

+	// Reduce the size the the base fs and loopback for the tests

+	DefaultDataLoopbackSize = 300 * 1024 * 1024

+	DefaultMetaDataLoopbackSize = 200 * 1024 * 1024

+	DefaultBaseFsSize = 300 * 1024 * 1024

 }

-func dmAttachLoopDeviceFail(filename string, fd *int) string {

-	return ""

+// This avoids creating a new driver for each test if all tests are run

+// Make sure to put new tests between TestDevmapperSetup and TestDevmapperTeardown

+func TestDevmapperSetup(t *testing.T) {

+	graphtest.GetDriver(t, "devicemapper")

 }

-func sysGetBlockSizeFail(fd uintptr, size *uint64) sysErrno {

-	return 1

+func TestDevmapperCreateEmpty(t *testing.T) {

+	graphtest.DriverTestCreateEmpty(t, "devicemapper")

 }

-func dmUdevWaitFail(cookie uint) int {

-	return -1

+func TestDevmapperCreateBase(t *testing.T) {

+	graphtest.DriverTestCreateBase(t, "devicemapper")

 }

-func dmSetDevDirFail(dir string) int {

-	return -1

+func TestDevmapperCreateSnap(t *testing.T) {

+	graphtest.DriverTestCreateSnap(t, "devicemapper")

 }

-func dmGetLibraryVersionFail(version *string) int {

-	return -1

+func TestDevmapperTeardown(t *testing.T) {

+	graphtest.PutDriver(t)

 }

deleted file mode 100644

@@ -1,939 +0,0 @@

-// +build linux,amd64

-

-package devmapper

-

-import (

-	"fmt"

-	"github.com/dotcloud/docker/daemon/graphdriver"

-	"github.com/dotcloud/docker/daemon/graphdriver/graphtest"

-	"io/ioutil"

-	"path"

-	"runtime"

-	"strings"

-	"syscall"

-	"testing"

-)

-

-func init() {

-	// Reduce the size the the base fs and loopback for the tests

-	DefaultDataLoopbackSize = 300 * 1024 * 1024

-	DefaultMetaDataLoopbackSize = 200 * 1024 * 1024

-	DefaultBaseFsSize = 300 * 1024 * 1024

-}

-

-// We use assignment here to get the right type

-var (

-	oldMounted = Mounted

-	oldExecRun = execRun

-)

-

-// denyAllDevmapper mocks all calls to libdevmapper in the unit tests, and denies them by default

-func denyAllDevmapper() {

-	oldExecRun = execRun

-

-	// Hijack all calls to libdevmapper with default panics.

-	// Authorized calls are selectively hijacked in each tests.

-	DmTaskCreate = func(t int) *CDmTask {

-		panic("DmTaskCreate: this method should not be called here")

-	}

-	DmTaskRun = func(task *CDmTask) int {

-		panic("DmTaskRun: this method should not be called here")

-	}

-	DmTaskSetName = func(task *CDmTask, name string) int {

-		panic("DmTaskSetName: this method should not be called here")

-	}

-	DmTaskSetMessage = func(task *CDmTask, message string) int {

-		panic("DmTaskSetMessage: this method should not be called here")

-	}

-	DmTaskSetSector = func(task *CDmTask, sector uint64) int {

-		panic("DmTaskSetSector: this method should not be called here")

-	}

-	DmTaskSetCookie = func(task *CDmTask, cookie *uint, flags uint16) int {

-		panic("DmTaskSetCookie: this method should not be called here")

-	}

-	DmTaskSetAddNode = func(task *CDmTask, addNode AddNodeType) int {

-		panic("DmTaskSetAddNode: this method should not be called here")

-	}

-	DmTaskSetRo = func(task *CDmTask) int {

-		panic("DmTaskSetRo: this method should not be called here")

-	}

-	DmTaskAddTarget = func(task *CDmTask, start, size uint64, ttype, params string) int {

-		panic("DmTaskAddTarget: this method should not be called here")

-	}

-	DmTaskGetInfo = func(task *CDmTask, info *Info) int {

-		panic("DmTaskGetInfo: this method should not be called here")

-	}

-	DmGetNextTarget = func(task *CDmTask, next uintptr, start, length *uint64, target, params *string) uintptr {

-		panic("DmGetNextTarget: this method should not be called here")

-	}

-	DmUdevWait = func(cookie uint) int {

-		panic("DmUdevWait: this method should not be called here")

-	}

-	DmSetDevDir = func(dir string) int {

-		panic("DmSetDevDir: this method should not be called here")

-	}

-	DmGetLibraryVersion = func(version *string) int {

-		panic("DmGetLibraryVersion: this method should not be called here")

-	}

-	DmLogInitVerbose = func(level int) {

-		panic("DmLogInitVerbose: this method should not be called here")

-	}

-	DmTaskDestroy = func(task *CDmTask) {

-		panic("DmTaskDestroy: this method should not be called here")

-	}

-	LogWithErrnoInit = func() {

-		panic("LogWithErrnoInit: this method should not be called here")

-	}

-}

-

-func restoreAllDevmapper() {

-	DmGetLibraryVersion = dmGetLibraryVersionFct

-	DmGetNextTarget = dmGetNextTargetFct

-	DmLogInitVerbose = dmLogInitVerboseFct

-	DmSetDevDir = dmSetDevDirFct

-	DmTaskAddTarget = dmTaskAddTargetFct

-	DmTaskCreate = dmTaskCreateFct

-	DmTaskDestroy = dmTaskDestroyFct

-	DmTaskGetInfo = dmTaskGetInfoFct

-	DmTaskRun = dmTaskRunFct

-	DmTaskSetAddNode = dmTaskSetAddNodeFct

-	DmTaskSetCookie = dmTaskSetCookieFct

-	DmTaskSetMessage = dmTaskSetMessageFct

-	DmTaskSetName = dmTaskSetNameFct

-	DmTaskSetRo = dmTaskSetRoFct

-	DmTaskSetSector = dmTaskSetSectorFct

-	DmUdevWait = dmUdevWaitFct

-	LogWithErrnoInit = logWithErrnoInitFct

-	execRun = oldExecRun

-}

-

-func denyAllSyscall() {

-	oldMounted = Mounted

-	sysMount = func(source, target, fstype string, flags uintptr, data string) (err error) {

-		panic("sysMount: this method should not be called here")

-	}

-	sysUnmount = func(target string, flags int) (err error) {

-		panic("sysUnmount: this method should not be called here")

-	}

-	sysCloseOnExec = func(fd int) {

-		panic("sysCloseOnExec: this method should not be called here")

-	}

-	sysSyscall = func(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {

-		panic("sysSyscall: this method should not be called here")

-	}

-	// Not a syscall, but forbidding it here anyway

-	Mounted = func(mnt string) (bool, error) {

-		panic("devmapper.Mounted: this method should not be called here")

-	}

-	// osOpenFile = os.OpenFile

-	// osNewFile = os.NewFile

-	// osCreate = os.Create

-	// osStat = os.Stat

-	// osIsNotExist = os.IsNotExist

-	// osIsExist = os.IsExist

-	// osMkdirAll = os.MkdirAll

-	// osRemoveAll = os.RemoveAll

-	// osRename = os.Rename

-	// osReadlink = os.Readlink

-

-	// execRun = func(name string, args ...string) error {

-	// 	return exec.Command(name, args...).Run()

-	// }

-}

-

-func restoreAllSyscall() {

-	sysMount = syscall.Mount

-	sysUnmount = syscall.Unmount

-	sysCloseOnExec = syscall.CloseOnExec

-	sysSyscall = syscall.Syscall

-	Mounted = oldMounted

-}

-

-func mkTestDirectory(t *testing.T) string {

-	dir, err := ioutil.TempDir("", "docker-test-devmapper-")

-	if err != nil {

-		t.Fatal(err)

-	}

-	return dir

-}

-

-func newDriver(t *testing.T) *Driver {

-	home := mkTestDirectory(t)

-	d, err := Init(home)

-	if err != nil {

-		t.Fatal(err)

-	}

-	return d.(*Driver)

-}

-

-func cleanup(d *Driver) {

-	d.Cleanup()

-	osRemoveAll(d.home)

-}

-

-type Set map[string]bool

-

-func (r Set) Assert(t *testing.T, names ...string) {

-	for _, key := range names {

-		required := true

-		if strings.HasPrefix(key, "?") {

-			key = key[1:]

-			required = false

-		}

-		if _, exists := r[key]; !exists && required {

-			t.Fatalf("Key not set: %s", key)

-		}

-		delete(r, key)

-	}

-	if len(r) != 0 {

-		t.Fatalf("Unexpected keys: %v", r)

-	}

-}

-

-func TestInit(t *testing.T) {

-	var (

-		calls        = make(Set)

-		taskMessages = make(Set)

-		taskTypes    = make(Set)

-		home         = mkTestDirectory(t)

-	)

-	defer osRemoveAll(home)

-

-	denyAllDevmapper()

-	defer restoreAllDevmapper()

-

-	func() {

-		DmSetDevDir = func(dir string) int {

-			calls["DmSetDevDir"] = true

-			expectedDir := "/dev"

-			if dir != expectedDir {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmSetDevDir(%v)\nReceived: DmSetDevDir(%v)\n", expectedDir, dir)

-			}

-			return 0

-		}

-		LogWithErrnoInit = func() {

-			calls["DmLogWithErrnoInit"] = true

-		}

-		var task1 CDmTask

-		DmTaskCreate = func(taskType int) *CDmTask {

-			calls["DmTaskCreate"] = true

-			taskTypes[fmt.Sprintf("%d", taskType)] = true

-			return &task1

-		}

-		DmTaskSetName = func(task *CDmTask, name string) int {

-			calls["DmTaskSetName"] = true

-			expectedTask := &task1

-			if task != expectedTask {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmTaskSetName(%v)\nReceived: DmTaskSetName(%v)\n", expectedTask, task)

-			}

-			// FIXME: use Set.AssertRegexp()

-			if !strings.HasPrefix(name, "docker-") && !strings.HasPrefix(name, "/dev/mapper/docker-") ||

-				!strings.HasSuffix(name, "-pool") && !strings.HasSuffix(name, "-base") {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmTaskSetName(%v)\nReceived: DmTaskSetName(%v)\n", "docker-...-pool", name)

-			}

-			return 1

-		}

-		DmTaskRun = func(task *CDmTask) int {

-			calls["DmTaskRun"] = true

-			expectedTask := &task1

-			if task != expectedTask {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmTaskRun(%v)\nReceived: DmTaskRun(%v)\n", expectedTask, task)

-			}

-			return 1

-		}

-		DmTaskGetInfo = func(task *CDmTask, info *Info) int {

-			calls["DmTaskGetInfo"] = true

-			expectedTask := &task1

-			if task != expectedTask {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmTaskGetInfo(%v)\nReceived: DmTaskGetInfo(%v)\n", expectedTask, task)

-			}

-			// This will crash if info is not dereferenceable

-			info.Exists = 0

-			return 1

-		}

-		DmTaskSetSector = func(task *CDmTask, sector uint64) int {

-			calls["DmTaskSetSector"] = true

-			expectedTask := &task1

-			if task != expectedTask {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmTaskSetSector(%v)\nReceived: DmTaskSetSector(%v)\n", expectedTask, task)

-			}

-			if expectedSector := uint64(0); sector != expectedSector {

-				t.Fatalf("Wrong libdevmapper call to DmTaskSetSector\nExpected: %v\nReceived: %v\n", expectedSector, sector)

-			}

-			return 1

-		}

-		DmTaskSetMessage = func(task *CDmTask, message string) int {

-			calls["DmTaskSetMessage"] = true

-			expectedTask := &task1

-			if task != expectedTask {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmTaskSetSector(%v)\nReceived: DmTaskSetSector(%v)\n", expectedTask, task)

-			}

-			taskMessages[message] = true

-			return 1

-		}

-		DmTaskDestroy = func(task *CDmTask) {

-			calls["DmTaskDestroy"] = true

-			expectedTask := &task1

-			if task != expectedTask {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmTaskDestroy(%v)\nReceived: DmTaskDestroy(%v)\n", expectedTask, task)

-			}

-		}

-		DmTaskAddTarget = func(task *CDmTask, start, size uint64, ttype, params string) int {

-			calls["DmTaskSetTarget"] = true

-			expectedTask := &task1

-			if task != expectedTask {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmTaskDestroy(%v)\nReceived: DmTaskDestroy(%v)\n", expectedTask, task)

-			}

-			if start != 0 {

-				t.Fatalf("Wrong start: %d != %d", start, 0)

-			}

-			if ttype != "thin" && ttype != "thin-pool" {

-				t.Fatalf("Wrong ttype: %s", ttype)

-			}

-			// Quick smoke test

-			if params == "" {

-				t.Fatalf("Params should not be empty")

-			}

-			return 1

-		}

-		fakeCookie := uint(4321)

-		DmTaskSetCookie = func(task *CDmTask, cookie *uint, flags uint16) int {

-			calls["DmTaskSetCookie"] = true

-			expectedTask := &task1

-			if task != expectedTask {

-				t.Fatalf("Wrong libdevmapper call\nExpected: DmTaskDestroy(%v)\nReceived: DmTaskDestroy(%v)\n", expectedTask, task)

-			}

-			if flags != 0 {

-				t.Fatalf("Cookie flags should be 0 (not %x)", flags)

-			}

-			*cookie = fakeCookie

-			return 1

-		}

-		DmUdevWait = func(cookie uint) int {

-			calls["DmUdevWait"] = true

-			if cookie != fakeCookie {

-				t.Fatalf("Wrong cookie: %d != %d", cookie, fakeCookie)

-			}

-			return 1

-		}

-		DmTaskSetAddNode = func(task *CDmTask, addNode AddNodeType) int {

-			if addNode != AddNodeOnCreate {

-				t.Fatalf("Wrong AddNoteType: %v (expected %v)", addNode, AddNodeOnCreate)

-			}

-			calls["DmTaskSetAddNode"] = true

-			return 1

-		}

-		execRun = func(name string, args ...string) error {

-			calls["execRun"] = true

-			if name != "mkfs.ext4" {

-				t.Fatalf("Expected %s to be executed, not %s", "mkfs.ext4", name)

-			}

-			return nil

-		}

-		driver, err := Init(home)

-		if err != nil {

-			t.Fatal(err)

-		}

-		defer func() {

-			if err := driver.Cleanup(); err != nil {

-				t.Fatal(err)

-			}

-		}()

-	}()

-	// Put all tests in a function to make sure the garbage collection will

-	// occur.

-

-	// Call GC to cleanup runtime.Finalizers

-	runtime.GC()

-

-	calls.Assert(t,

-		"DmSetDevDir",

-		"DmLogWithErrnoInit",

-		"DmTaskSetName",

-		"DmTaskRun",

-		"DmTaskGetInfo",

-		"DmTaskDestroy",

-		"execRun",

-		"DmTaskCreate",

-		"DmTaskSetTarget",

-		"DmTaskSetCookie",

-		"DmUdevWait",

-		"DmTaskSetSector",

-		"DmTaskSetMessage",

-		"DmTaskSetAddNode",

-	)

-	taskTypes.Assert(t, "0", "6", "17")

-	taskMessages.Assert(t, "create_thin 0", "set_transaction_id 0 1")

-}

-

-func fakeInit() func(home string) (graphdriver.Driver, error) {

-	oldInit := Init

-	Init = func(home string) (graphdriver.Driver, error) {

-		return &Driver{

-			home: home,

-		}, nil

-	}

-	return oldInit

-}

-

-func restoreInit(init func(home string) (graphdriver.Driver, error)) {

-	Init = init

-}

-

-func mockAllDevmapper(calls Set) {

-	DmSetDevDir = func(dir string) int {

-		calls["DmSetDevDir"] = true

-		return 0

-	}

-	LogWithErrnoInit = func() {

-		calls["DmLogWithErrnoInit"] = true

-	}

-	DmTaskCreate = func(taskType int) *CDmTask {

-		calls["DmTaskCreate"] = true

-		return &CDmTask{}

-	}

-	DmTaskSetName = func(task *CDmTask, name string) int {

-		calls["DmTaskSetName"] = true

-		return 1

-	}

-	DmTaskRun = func(task *CDmTask) int {

-		calls["DmTaskRun"] = true

-		return 1

-	}

-	DmTaskGetInfo = func(task *CDmTask, info *Info) int {

-		calls["DmTaskGetInfo"] = true

-		return 1

-	}

-	DmTaskSetSector = func(task *CDmTask, sector uint64) int {

-		calls["DmTaskSetSector"] = true

-		return 1

-	}

-	DmTaskSetMessage = func(task *CDmTask, message string) int {

-		calls["DmTaskSetMessage"] = true

-		return 1

-	}

-	DmTaskDestroy = func(task *CDmTask) {

-		calls["DmTaskDestroy"] = true

-	}

-	DmTaskAddTarget = func(task *CDmTask, start, size uint64, ttype, params string) int {

-		calls["DmTaskSetTarget"] = true

-		return 1

-	}

-	DmTaskSetCookie = func(task *CDmTask, cookie *uint, flags uint16) int {

-		calls["DmTaskSetCookie"] = true

-		return 1

-	}

-	DmUdevWait = func(cookie uint) int {

-		calls["DmUdevWait"] = true

-		return 1

-	}

-	DmTaskSetAddNode = func(task *CDmTask, addNode AddNodeType) int {

-		calls["DmTaskSetAddNode"] = true

-		return 1

-	}

-	execRun = func(name string, args ...string) error {

-		calls["execRun"] = true

-		return nil

-	}

-}

-

-func TestDriverName(t *testing.T) {

-	denyAllDevmapper()

-	defer restoreAllDevmapper()

-

-	oldInit := fakeInit()

-	defer restoreInit(oldInit)

-

-	d := newDriver(t)

-	if d.String() != "devicemapper" {

-		t.Fatalf("Expected driver name to be devicemapper got %s", d.String())

-	}

-}

-

-func TestDriverCreate(t *testing.T) {

-	denyAllDevmapper()

-	denyAllSyscall()

-	defer restoreAllSyscall()

-	defer restoreAllDevmapper()

-

-	calls := make(Set)

-	mockAllDevmapper(calls)

-

-	sysMount = func(source, target, fstype string, flags uintptr, data string) (err error) {

-		calls["sysMount"] = true

-		// FIXME: compare the exact source and target strings (inodes + devname)

-		if expectedSource := "/dev/mapper/docker-"; !strings.HasPrefix(source, expectedSource) {

-			t.Fatalf("Wrong syscall call\nExpected: Mount(%v)\nReceived: Mount(%v)\n", expectedSource, source)

-		}

-		if expectedTarget := "/tmp/docker-test-devmapper-"; !strings.HasPrefix(target, expectedTarget) {

-			t.Fatalf("Wrong syscall call\nExpected: Mount(%v)\nReceived: Mount(%v)\n", expectedTarget, target)

-		}

-		if expectedFstype := "ext4"; fstype != expectedFstype {

-			t.Fatalf("Wrong syscall call\nExpected: Mount(%v)\nReceived: Mount(%v)\n", expectedFstype, fstype)

-		}

-		if expectedFlags := uintptr(3236757504); flags != expectedFlags {

-			t.Fatalf("Wrong syscall call\nExpected: Mount(%v)\nReceived: Mount(%v)\n", expectedFlags, flags)

-		}

-		return nil

-	}

-

-	sysUnmount = func(target string, flag int) error {

-		//calls["sysUnmount"] = true

-

-		return nil

-	}

-

-	Mounted = func(mnt string) (bool, error) {

-		calls["Mounted"] = true

-		if !strings.HasPrefix(mnt, "/tmp/docker-test-devmapper-") || !strings.HasSuffix(mnt, "/mnt/1") {

-			t.Fatalf("Wrong mounted call\nExpected: Mounted(%v)\nReceived: Mounted(%v)\n", "/tmp/docker-test-devmapper-.../mnt/1", mnt)

-		}

-		return false, nil

-	}

-

-	sysSyscall = func(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {

-		calls["sysSyscall"] = true

-		if trap != sysSysIoctl {

-			t.Fatalf("Unexpected syscall. Expecting SYS_IOCTL, received: %d", trap)

-		}

-		switch a2 {

-		case LoopSetFd:

-			calls["ioctl.loopsetfd"] = true

-		case LoopCtlGetFree:

-			calls["ioctl.loopctlgetfree"] = true

-		case LoopGetStatus64:

-			calls["ioctl.loopgetstatus"] = true

-		case LoopSetStatus64:

-			calls["ioctl.loopsetstatus"] = true

-		case LoopClrFd:

-			calls["ioctl.loopclrfd"] = true

-		case LoopSetCapacity:

-			calls["ioctl.loopsetcapacity"] = true

-		case BlkGetSize64:

-			calls["ioctl.blkgetsize"] = true

-		default:

-			t.Fatalf("Unexpected IOCTL. Received %d", a2)

-		}

-		return 0, 0, 0

-	}

-

-	func() {

-		d := newDriver(t)

-

-		calls.Assert(t,

-			"DmSetDevDir",

-			"DmLogWithErrnoInit",

-			"DmTaskSetName",

-			"DmTaskRun",

-			"DmTaskGetInfo",

-			"execRun",

-			"DmTaskCreate",

-			"DmTaskSetTarget",

-			"DmTaskSetCookie",

-			"DmUdevWait",

-			"DmTaskSetSector",

-			"DmTaskSetMessage",

-			"DmTaskSetAddNode",

-			"sysSyscall",

-			"ioctl.blkgetsize",

-			"ioctl.loopsetfd",

-			"ioctl.loopsetstatus",

-			"?ioctl.loopctlgetfree",

-		)

-

-		if err := d.Create("1", ""); err != nil {

-			t.Fatal(err)

-		}

-		calls.Assert(t,

-			"DmTaskCreate",

-			"DmTaskGetInfo",

-			"DmTaskRun",

-			"DmTaskSetSector",

-			"DmTaskSetName",

-			"DmTaskSetMessage",

-		)

-

-	}()

-

-	runtime.GC()

-

-	calls.Assert(t,

-		"DmTaskDestroy",

-	)

-}

-

-func TestDriverRemove(t *testing.T) {

-	denyAllDevmapper()

-	denyAllSyscall()

-	defer restoreAllSyscall()

-	defer restoreAllDevmapper()

-

-	calls := make(Set)

-	mockAllDevmapper(calls)

-

-	sysMount = func(source, target, fstype string, flags uintptr, data string) (err error) {

-		calls["sysMount"] = true