// +build linux freebsd solaris

 package graphtest
 
 import (

 	"bytes"

 	"io/ioutil"

 	"math/rand"

 	"os"
 	"path"

 	"reflect"

 	"testing"

 	"unsafe"

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

 	"github.com/docker/docker/pkg/stringid"

 	"github.com/docker/go-units"

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"

 	"golang.org/x/sys/unix"

 )
 
 var (
 	drv *Driver
 )
 

 // Driver conforms to graphdriver.Driver interface and
 // contains information such as root and reference count of the number of clients using it.
 // This helps in testing drivers added into the framework.

 type Driver struct {
 	graphdriver.Driver
 	root     string
 	refCount int
 }
 

 func newDriver(t testing.TB, name string, options []string) *Driver {

 	root, err := ioutil.TempDir("", "docker-graphtest-")

 	require.NoError(t, err)

 	require.NoError(t, os.MkdirAll(root, 0755))

 	d, err := graphdriver.GetDriver(name, nil, graphdriver.Options{DriverOptions: options, Root: root})

 	if err != nil {

 		t.Logf("graphdriver: %v\n", err)

 		if err == graphdriver.ErrNotSupported || err == graphdriver.ErrPrerequisites || err == graphdriver.ErrIncompatibleFS {

 			t.Skipf("Driver %s not supported", name)

 		}

 		t.Fatal(err)
 	}
 	return &Driver{d, root, 1}
 }
 

 func cleanup(t testing.TB, d *Driver) {

 	if err := drv.Cleanup(); err != nil {
 		t.Fatal(err)
 	}
 	os.RemoveAll(d.root)
 }
 

 // GetDriver create a new driver with given name or return an existing driver with the name updating the reference count.

 func GetDriver(t testing.TB, name string, options ...string) graphdriver.Driver {

 	if drv == nil {

 		drv = newDriver(t, name, options)

 	} else {
 		drv.refCount++
 	}
 	return drv
 }
 

 // PutDriver removes the driver if it is no longer used and updates the reference count.

 func PutDriver(t testing.TB) {

 	if drv == nil {

 		t.Skip("No driver to put!")

 	}
 	drv.refCount--
 	if drv.refCount == 0 {
 		cleanup(t, drv)
 		drv = nil
 	}
 }
 

 // DriverTestCreateEmpty creates a new image and verifies it is empty and the right metadata
 func DriverTestCreateEmpty(t testing.TB, drivername string, driverOptions ...string) {
 	driver := GetDriver(t, drivername, driverOptions...)
 	defer PutDriver(t)
 

 	err := driver.Create("empty", "", nil)
 	require.NoError(t, err)

 	defer func() {

 		require.NoError(t, driver.Remove("empty"))

 	}()

 	if !driver.Exists("empty") {
 		t.Fatal("Newly created image doesn't exist")

 	}
 

 	dir, err := driver.Get("empty", "")

 	require.NoError(t, err)

 	verifyFile(t, dir, 0755|os.ModeDir, 0, 0)

 	// Verify that the directory is empty
 	fis, err := readDir(dir)

 	require.NoError(t, err)
 	assert.Len(t, fis, 0)

 	driver.Put("empty")

 }
 

 // DriverTestCreateBase create a base driver and verify.
 func DriverTestCreateBase(t testing.TB, drivername string, driverOptions ...string) {
 	driver := GetDriver(t, drivername, driverOptions...)
 	defer PutDriver(t)

 	createBase(t, driver, "Base")
 	defer func() {

 		require.NoError(t, driver.Remove("Base"))

 	}()
 	verifyBase(t, driver, "Base")

 }
 

 // DriverTestCreateSnap Create a driver and snap and verify.
 func DriverTestCreateSnap(t testing.TB, drivername string, driverOptions ...string) {
 	driver := GetDriver(t, drivername, driverOptions...)

 	defer PutDriver(t)
 

 	createBase(t, driver, "Base")
 	defer func() {

 		require.NoError(t, driver.Remove("Base"))

 	}()
 

 	err := driver.Create("Snap", "Base", nil)
 	require.NoError(t, err)

 	defer func() {

 		require.NoError(t, driver.Remove("Snap"))

 	}()
 

 	verifyBase(t, driver, "Snap")
 }

 // DriverTestDeepLayerRead reads a file from a lower layer under a given number of layers
 func DriverTestDeepLayerRead(t testing.TB, layerCount int, drivername string, driverOptions ...string) {
 	driver := GetDriver(t, drivername, driverOptions...)
 	defer PutDriver(t)
 
 	base := stringid.GenerateRandomID()

 	if err := driver.Create(base, "", nil); err != nil {

 		t.Fatal(err)
 	}
 

 	content := []byte("test content")
 	if err := addFile(driver, base, "testfile.txt", content); err != nil {
 		t.Fatal(err)
 	}

 	topLayer, err := addManyLayers(driver, base, layerCount)

 	if err != nil {
 		t.Fatal(err)
 	}
 

 	err = checkManyLayers(driver, topLayer, layerCount)
 	if err != nil {
 		t.Fatal(err)

 	}
 

 	if err := checkFile(driver, topLayer, "testfile.txt", content); err != nil {
 		t.Fatal(err)
 	}

 }
 

 // DriverTestDiffApply tests diffing and applying produces the same layer
 func DriverTestDiffApply(t testing.TB, fileCount int, drivername string, driverOptions ...string) {
 	driver := GetDriver(t, drivername, driverOptions...)
 	defer PutDriver(t)
 	base := stringid.GenerateRandomID()
 	upper := stringid.GenerateRandomID()

 	deleteFile := "file-remove.txt"
 	deleteFileContent := []byte("This file should get removed in upper!")

 	deleteDir := "var/lib"

 	if err := driver.Create(base, "", nil); err != nil {

 		t.Fatal(err)
 	}
 

 	if err := addManyFiles(driver, base, fileCount, 3); err != nil {

 		t.Fatal(err)
 	}
 

 	if err := addFile(driver, base, deleteFile, deleteFileContent); err != nil {
 		t.Fatal(err)
 	}
 

 	if err := addDirectory(driver, base, deleteDir); err != nil {
 		t.Fatal(err)
 	}
 

 	if err := driver.Create(upper, base, nil); err != nil {

 		t.Fatal(err)
 	}

 
 	if err := addManyFiles(driver, upper, fileCount, 6); err != nil {
 		t.Fatal(err)
 	}

 	if err := removeAll(driver, upper, deleteFile, deleteDir); err != nil {

 		t.Fatal(err)
 	}
 

 	diffSize, err := driver.DiffSize(upper, "")
 	if err != nil {

 		t.Fatal(err)
 	}
 

 	diff := stringid.GenerateRandomID()

 	if err := driver.Create(diff, base, nil); err != nil {

 		t.Fatal(err)
 	}
 

 	if err := checkManyFiles(driver, diff, fileCount, 3); err != nil {

 		t.Fatal(err)
 	}
 

 	if err := checkFile(driver, diff, deleteFile, deleteFileContent); err != nil {
 		t.Fatal(err)
 	}
 

 	arch, err := driver.Diff(upper, base)
 	if err != nil {
 		t.Fatal(err)
 	}

 	buf := bytes.NewBuffer(nil)
 	if _, err := buf.ReadFrom(arch); err != nil {
 		t.Fatal(err)
 	}
 	if err := arch.Close(); err != nil {
 		t.Fatal(err)
 	}

 	applyDiffSize, err := driver.ApplyDiff(diff, base, bytes.NewReader(buf.Bytes()))

 	if err != nil {
 		t.Fatal(err)
 	}
 

 	if applyDiffSize != diffSize {
 		t.Fatalf("Apply diff size different, got %d, expected %d", applyDiffSize, diffSize)
 	}

 	if err := checkManyFiles(driver, diff, fileCount, 6); err != nil {
 		t.Fatal(err)

 	}

 
 	if err := checkFileRemoved(driver, diff, deleteFile); err != nil {
 		t.Fatal(err)
 	}

 
 	if err := checkFileRemoved(driver, diff, deleteDir); err != nil {
 		t.Fatal(err)
 	}

 }
 

 // DriverTestChanges tests computed changes on a layer matches changes made
 func DriverTestChanges(t testing.TB, drivername string, driverOptions ...string) {
 	driver := GetDriver(t, drivername, driverOptions...)

 	defer PutDriver(t)

 	base := stringid.GenerateRandomID()
 	upper := stringid.GenerateRandomID()

 	if err := driver.Create(base, "", nil); err != nil {

 		t.Fatal(err)
 	}

 	if err := addManyFiles(driver, base, 20, 3); err != nil {
 		t.Fatal(err)
 	}

 	if err := driver.Create(upper, base, nil); err != nil {

 		t.Fatal(err)
 	}

 	expectedChanges, err := changeManyFiles(driver, upper, 20, 6)
 	if err != nil {
 		t.Fatal(err)
 	}

 	changes, err := driver.Changes(upper, base)
 	if err != nil {

 		t.Fatal(err)
 	}
 

 	if err = checkChanges(expectedChanges, changes); err != nil {
 		t.Fatal(err)
 	}

 }

 
 func writeRandomFile(path string, size uint64) error {
 	buf := make([]int64, size/8)
 
 	r := rand.NewSource(0)
 	for i := range buf {
 		buf[i] = r.Int63()
 	}
 
 	// Cast to []byte
 	header := *(*reflect.SliceHeader)(unsafe.Pointer(&buf))
 	header.Len *= 8
 	header.Cap *= 8
 	data := *(*[]byte)(unsafe.Pointer(&header))
 
 	return ioutil.WriteFile(path, data, 0700)
 }
 
 // DriverTestSetQuota Create a driver and test setting quota.
 func DriverTestSetQuota(t *testing.T, drivername string) {
 	driver := GetDriver(t, drivername)
 	defer PutDriver(t)
 
 	createBase(t, driver, "Base")

 	createOpts := &graphdriver.CreateOpts{}
 	createOpts.StorageOpt = make(map[string]string, 1)
 	createOpts.StorageOpt["size"] = "50M"
 	if err := driver.Create("zfsTest", "Base", createOpts); err != nil {

 		t.Fatal(err)
 	}
 
 	mountPath, err := driver.Get("zfsTest", "")
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	quota := uint64(50 * units.MiB)
 	err = writeRandomFile(path.Join(mountPath, "file"), quota*2)

 	if pathError, ok := err.(*os.PathError); ok && pathError.Err != unix.EDQUOT {
 		t.Fatalf("expect write() to fail with %v, got %v", unix.EDQUOT, err)

 	}
 
 }