288 lines
6.3 KiB
Go
288 lines
6.3 KiB
Go
// +build linux
|
|
|
|
package devmapper
|
|
|
|
import (
|
|
"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 dmAttachLoopDeviceFail(filename string, fd *int) string {
|
|
return ""
|
|
}
|
|
|
|
func sysGetBlockSizeFail(fd uintptr, size *uint64) sysErrno {
|
|
return 1
|
|
}
|
|
|
|
func dmUdevWaitFail(cookie uint) int {
|
|
return -1
|
|
}
|
|
|
|
func dmSetDevDirFail(dir string) int {
|
|
return -1
|
|
}
|
|
|
|
func dmGetLibraryVersionFail(version *string) int {
|
|
return -1
|
|
}
|