package squashfs

// import (
// 	"bytes"
// 	"flag"
// 	"fmt"
// 	"io"
// 	"io/ioutil"
// 	"os"
// 	"os/exec"
// 	"path/filepath"
// 	"strings"
// 	"testing"
// 	"time"

// 	"github.com/distr1/distri"
// 	// "github.com/distr1/distri/internal/distritest"
// 	"github.com/google/go-cmp/cmp"
// 	"github.com/orcaman/writerseeker"
// 	"golang.org/x/sys/unix"
// )

// var fsImagePath = flag.String("fs_image_path", "", "Store the SquashFS test file system in the specified path for manual inspection")

// func writeTestImage(iow io.WriteSeeker, xattr bool) error {
// 	w, err := NewWriter(iow, time.Now())
// 	if err != nil {
// 		return err
// 	}

// 	var xattrs []Xattr
// 	if xattr {
// 		xattrs = append(xattrs, Xattr{
// 			Type:     2,
// 			FullName: "capability",
// 			Value:    []byte{1, 0, 0, 2, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
// 		})
// 	}
// 	ff, err := w.Root.File("hellö wörld", time.Now(), unix.S_IRUSR|unix.S_IRGRP|unix.S_IROTH, xattrs)
// 	if err != nil {
// 		return err
// 	}
// 	if _, err := ff.Write([]byte("hello world!")); err != nil {
// 		return err
// 	}
// 	if err := ff.Close(); err != nil {
// 		return err
// 	}

// 	ff, err = w.Root.File("leer", time.Now(), unix.S_IRUSR|unix.S_IRGRP|unix.S_IROTH, nil)
// 	if err != nil {
// 		return err
// 	}
// 	if err := ff.Close(); err != nil {
// 		return err
// 	}

// 	ff, err = w.Root.File("second file", time.Now(), unix.S_IRUSR|unix.S_IXUSR|
// 		unix.S_IRGRP|unix.S_IXGRP|
// 		unix.S_IROTH|unix.S_IXOTH,
// 		nil)
// 	if err != nil {
// 		return err
// 	}
// 	if _, err := ff.Write([]byte("NON.\n")); err != nil {
// 		return err
// 	}
// 	if err := ff.Close(); err != nil {
// 		return err
// 	}

// 	if err := w.Root.Symlink("second file", "second link", time.Now(), unix.S_IRUSR|unix.S_IRGRP|unix.S_IROTH); err != nil {
// 		return err
// 	}

// 	subdir := w.Root.Directory("subdir", time.Now())

// 	subsubdir := subdir.Directory("deep", time.Now())
// 	ff, err = subsubdir.File("yo", time.Now(), unix.S_IRUSR|unix.S_IRGRP|unix.S_IROTH, nil)
// 	if err != nil {
// 		return err
// 	}
// 	if _, err := ff.Write([]byte("foo\n")); err != nil {
// 		return err
// 	}
// 	if err := ff.Close(); err != nil {
// 		return err
// 	}
// 	if err := subsubdir.Flush(); err != nil {
// 		return err
// 	}

// 	// TODO: write another file in subdir now, will result in invalid parent inode

// 	ff, err = subdir.File("third file (in subdir)", time.Now(), unix.S_IRUSR|unix.S_IRGRP|unix.S_IROTH, nil)
// 	if err != nil {
// 		return err
// 	}
// 	if _, err := ff.Write([]byte("contents\n")); err != nil {
// 		return err
// 	}
// 	if err := ff.Close(); err != nil {
// 		return err
// 	}

// 	if err := subdir.Flush(); err != nil {
// 		return err
// 	}
// 	ff, err = w.Root.File("testbin", time.Now(), unix.S_IRUSR|unix.S_IXUSR|
// 		unix.S_IRGRP|unix.S_IXGRP|
// 		unix.S_IROTH|unix.S_IXOTH,
// 		nil)
// 	if err != nil {
// 		return err
// 	}
// 	zf, err := os.Open(os.Args[0])
// 	if err != nil {
// 		return err
// 	}
// 	defer zf.Close()
// 	if _, err := io.Copy(ff, zf); err != nil {
// 		return err
// 	}
// 	if err := ff.Close(); err != nil {
// 		return err
// 	}

// 	if err := w.Root.Flush(); err != nil {
// 		return err
// 	}
// 	if err := w.Flush(); err != nil {
// 		return err
// 	}
// 	return nil
// }

// func TestUnsquashfs(t *testing.T) {
// 	t.Parallel()

// 	ctx, canc := distri.InterruptibleContext()
// 	defer canc()

// 	if _, err := exec.LookPath("unsquashfs"); err != nil {
// 		t.Skip("unsquashfs not found in $PATH")
// 	}

// 	for _, xattr := range []bool{false, true} {
// 		t.Run(fmt.Sprintf("xattr %v", xattr), func(t *testing.T) {
// 			var (
// 				f   *os.File
// 				err error
// 			)
// 			if *fsImagePath != "" {
// 				f, err = os.Create(*fsImagePath + fmt.Sprintf("-xattr-%v", xattr))
// 			} else {
// 				f, err = ioutil.TempFile("", fmt.Sprintf("squashfs-xattr-%v", xattr))
// 				if err == nil {
// 					defer os.Remove(f.Name())
// 				}
// 			}
// 			if err != nil {
// 				t.Fatal(err)
// 			}

// 			if err := writeTestImage(f, xattr); err != nil {
// 				t.Fatal(err)
// 			}

// 			if err := f.Close(); err != nil {
// 				t.Fatal(err)
// 			}

// 			// Extract our generated file system using unsquashfs(1)
// 			out, err := ioutil.TempDir("", fmt.Sprintf("unsquashfs-xattr-%v", xattr))
// 			if err != nil {
// 				t.Fatal(err)
// 			}
// 			// defer distritest.RemoveAll(t, out)
// 			cmd := exec.CommandContext(ctx, "unsquashfs", "-no-xattrs", "-d", filepath.Join(out, "x"), f.Name())
// 			cmd.Stderr = os.Stderr
// 			if err := cmd.Run(); err != nil {
// 				t.Fatal(err)
// 			}

// 			fbin, err := os.Open(os.Args[0])
// 			if err != nil {
// 				t.Fatal(err)
// 			}

// 			// Verify the extracted files match our expectations.
// 			for _, entry := range []struct {
// 				path     string
// 				contents io.Reader
// 			}{
// 				{"leer", strings.NewReader("")},
// 				{"hellö wörld", strings.NewReader("hello world!")},
// 				{"testbin", fbin},
// 				{"subdir/third file (in subdir)", strings.NewReader("contents\n")},
// 			} {
// 				entry := entry // copy
// 				t.Run(entry.path, func(t *testing.T) {
// 					in, err := os.Open(filepath.Join(out, "x", entry.path))
// 					if err != nil {
// 						t.Fatal(err)
// 					}
// 					got, err := ioutil.ReadAll(in)
// 					if err != nil {
// 						t.Fatal(err)
// 					}
// 					want, err := ioutil.ReadAll(entry.contents)
// 					if err != nil {
// 						t.Fatal(err)
// 					}
// 					if !bytes.Equal(got, want) {
// 						t.Fatalf("path %q differs", entry.path)
// 					}
// 				})
// 			}
// 		})
// 	}
// }

// func TestReader(t *testing.T) {
// 	t.Parallel()

// 	for _, xattr := range []bool{false, true} {
// 		t.Run(fmt.Sprintf("xattr %v", xattr), func(t *testing.T) {
// 			var err error
// 			buf := &writerseeker.WriterSeeker{}
// 			if err := writeTestImage(buf, xattr); err != nil {
// 				t.Fatal(err)
// 			}

// 			if _, err := buf.Seek(0, io.SeekCurrent); err != nil {
// 				t.Fatal(err)
// 			}

// 			rd, err := NewReader(buf.BytesReader())
// 			if err != nil {
// 				t.Fatal(err)
// 			}

// 			fbin, err := os.Open(os.Args[0])
// 			if err != nil {
// 				t.Fatal(err)
// 			}

// 			// Verify the extracted files match our expectations.
// 			for _, entry := range []struct {
// 				path     string
// 				contents io.Reader
// 			}{
// 				{"leer", strings.NewReader("")},
// 				{"hellö wörld", strings.NewReader("hello world!")},
// 				{"testbin", fbin},
// 				{"subdir/third file (in subdir)", strings.NewReader("contents\n")},
// 			} {
// 				entry := entry // copy
// 				t.Run(entry.path, func(t *testing.T) {
// 					// TODO: is this t.Parallel()-safe?
// 					inode, err := rd.LookupPath(entry.path)
// 					if err != nil {
// 						t.Fatal(err)
// 					}
// 					in, err := rd.FileReader(inode)
// 					if err != nil {
// 						t.Fatal(err)
// 					}
// 					got, err := ioutil.ReadAll(in)
// 					if err != nil {
// 						t.Fatal(err)
// 					}
// 					want, err := ioutil.ReadAll(entry.contents)
// 					if err != nil {
// 						t.Fatal(err)
// 					}
// 					if !bytes.Equal(got, want) {
// 						t.Fatalf("path %q differs", entry.path)
// 					}
// 				})
// 			}

// 			if xattr {
// 				t.Run("xattrs", func(t *testing.T) {
// 					inode, err := rd.LookupPath("hellö wörld")
// 					if err != nil {
// 						t.Fatal(err)
// 					}

// 					xattrs, err := rd.ReadXattrs(inode)
// 					if err != nil {
// 						t.Fatal(err)
// 					}

// 					if got, want := len(xattrs), 1; got != want {
// 						t.Fatalf("unexpected number of extended attributes: got %d, want %d", got, want)
// 					}
// 					wantXattr := Xattr{
// 						Type:     2,
// 						FullName: "security.capability",
// 						Value:    []byte{1, 0, 0, 2, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
// 					}
// 					if diff := cmp.Diff(wantXattr, xattrs[0]); diff != "" {
// 						t.Errorf("unexpected extended attribute: diff (-want +got):\n%s", diff)
// 					}
// 				})
// 			}
// 		})
// 	}
// }