src/os/readfrom_unix_test.go - go - Git at Google

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

 //go:build freebsd || linux || solaris

 package os_test

 import (
 	"bytes"
 	"io"
 	"math/rand"
 	. "os"
 	"runtime"
 	"strconv"
 	"strings"
 	"syscall"
 	"testing"
 	"time"
 )

 type (
 	copyFileTestFunc func(*testing.T, int64) (*File, *File, []byte, *copyFileHook, string)
 	copyFileTestHook func(*testing.T) (*copyFileHook, string)
 )

 func TestCopyFile(t *testing.T) {
 	sizes := []int{
 		1,
 		42,
 		1025,
 		syscall.Getpagesize() + 1,
 		32769,
 	}
 	t.Run("Basic", func(t *testing.T) {
 		for _, size := range sizes {
 			t.Run(strconv.Itoa(size), func(t *testing.T) {
 				testCopyFiles(t, int64(size), -1)
 			})
 		}
 	})
 	t.Run("Limited", func(t *testing.T) {
 		t.Run("OneLess", func(t *testing.T) {
 			for _, size := range sizes {
 				t.Run(strconv.Itoa(size), func(t *testing.T) {
 					testCopyFiles(t, int64(size), int64(size)-1)
 				})
 			}
 		})
 		t.Run("Half", func(t *testing.T) {
 			for _, size := range sizes {
 				t.Run(strconv.Itoa(size), func(t *testing.T) {
 					testCopyFiles(t, int64(size), int64(size)/2)
 				})
 			}
 		})
 		t.Run("More", func(t *testing.T) {
 			for _, size := range sizes {
 				t.Run(strconv.Itoa(size), func(t *testing.T) {
 					testCopyFiles(t, int64(size), int64(size)+7)
 				})
 			}
 		})
 	})
 	t.Run("DoesntTryInAppendMode", func(t *testing.T) {
 		for _, newTest := range copyFileTests {
 			dst, src, data, hook, testName := newTest(t, 42)

 			dst2, err := OpenFile(dst.Name(), O_RDWR|O_APPEND, 0755)
 			if err != nil {
 				t.Fatalf("%s: %v", testName, err)
 			}
 			defer dst2.Close()

 			if _, err := io.Copy(dst2, src); err != nil {
 				t.Fatalf("%s: %v", testName, err)
 			}
 			switch runtime.GOOS {
 			case "illumos", "solaris": // sendfile() on SunOS allows target file with O_APPEND set.
 				if !hook.called {
 					t.Fatalf("%s: should have called the hook even with destination in O_APPEND mode", testName)
 				}
 			default:
 				if hook.called {
 					t.Fatalf("%s: hook shouldn't be called with destination in O_APPEND mode", testName)
 				}
 			}
 			mustSeekStart(t, dst2)
 			mustContainData(t, dst2, data) // through traditional means
 		}
 	})
 	t.Run("CopyFileItself", func(t *testing.T) {
 		for _, hookFunc := range copyFileHooks {
 			hook, testName := hookFunc(t)

 			f, err := CreateTemp("", "file-readfrom-itself-test")
 			if err != nil {
 				t.Fatalf("%s: failed to create tmp file: %v", testName, err)
 			}
 			t.Cleanup(func() {
 				f.Close()
 				Remove(f.Name())
 			})

 			data := []byte("hello world!")
 			if _, err := f.Write(data); err != nil {
 				t.Fatalf("%s: failed to create and feed the file: %v", testName, err)
 			}

 			if err := f.Sync(); err != nil {
 				t.Fatalf("%s: failed to save the file: %v", testName, err)
 			}

 			// Rewind it.
 			if _, err := f.Seek(0, io.SeekStart); err != nil {
 				t.Fatalf("%s: failed to rewind the file: %v", testName, err)
 			}

 			// Read data from the file itself.
 			if _, err := io.Copy(f, f); err != nil {
 				t.Fatalf("%s: failed to read from the file: %v", testName, err)
 			}

 			if hook.written != 0 || hook.handled || hook.err != nil {
 				t.Fatalf("%s: File.readFrom is expected not to use any zero-copy techniques when copying itself."+
 					"got hook.written=%d, hook.handled=%t, hook.err=%v; expected hook.written=0, hook.handled=false, hook.err=nil",
 					testName, hook.written, hook.handled, hook.err)
 			}

 			switch testName {
 			case "hookCopyFileRange":
 				// For copy_file_range(2), it fails and returns EINVAL when the source and target
 				// refer to the same file and their ranges overlap. The hook should be called to
 				// get the returned error and fall back to generic copy.
 				if !hook.called {
 					t.Fatalf("%s: should have called the hook", testName)
 				}
 			case "hookSendFile", "hookSendFileOverCopyFileRange":
 				// For sendfile(2), it allows the source and target to refer to the same file and overlap.
 				// The hook should not be called and just fall back to generic copy directly.
 				if hook.called {
 					t.Fatalf("%s: shouldn't have called the hook", testName)
 				}
 			default:
 				t.Fatalf("%s: unexpected test", testName)
 			}

 			// Rewind it.
 			if _, err := f.Seek(0, io.SeekStart); err != nil {
 				t.Fatalf("%s: failed to rewind the file: %v", testName, err)
 			}

 			data2, err := io.ReadAll(f)
 			if err != nil {
 				t.Fatalf("%s: failed to read from the file: %v", testName, err)
 			}

 			// It should wind up a double of the original data.
 			if s := strings.Repeat(string(data), 2); s != string(data2) {
 				t.Fatalf("%s: file contained %s, expected %s", testName, data2, s)
 			}
 		}
 	})
 	t.Run("NotRegular", func(t *testing.T) {
 		t.Run("BothPipes", func(t *testing.T) {
 			for _, hookFunc := range copyFileHooks {
 				hook, testName := hookFunc(t)

 				pr1, pw1, err := Pipe()
 				if err != nil {
 					t.Fatalf("%s: %v", testName, err)
 				}
 				defer pr1.Close()
 				defer pw1.Close()

 				pr2, pw2, err := Pipe()
 				if err != nil {
 					t.Fatalf("%s: %v", testName, err)
 				}
 				defer pr2.Close()
 				defer pw2.Close()

 				// The pipe is empty, and PIPE_BUF is large enough
 				// for this, by (POSIX) definition, so there is no
 				// need for an additional goroutine.
 				data := []byte("hello")
 				if _, err := pw1.Write(data); err != nil {
 					t.Fatalf("%s: %v", testName, err)
 				}
 				pw1.Close()

 				n, err := io.Copy(pw2, pr1)
 				if err != nil {
 					t.Fatalf("%s: %v", testName, err)
 				}
 				if n != int64(len(data)) {
 					t.Fatalf("%s: transferred %d, want %d", testName, n, len(data))
 				}
 				switch runtime.GOOS {
 				case "illumos", "solaris":
 					// On solaris, We rely on File.Stat to get the size of the source file,
 					// which doesn't work for pipe.
 					// On illumos, We skip anything other than regular files conservatively
 					// for the target file, therefore the hook shouldn't have been called.
 					if hook.called {
 						t.Fatalf("%s: shouldn't have called the hook with a source or a destination of pipe", testName)
 					}
 				default:
 					if !hook.called {
 						t.Fatalf("%s: should have called the hook with both source and destination of pipe", testName)
 					}
 				}
 				pw2.Close()
 				mustContainData(t, pr2, data)
 			}
 		})
 		t.Run("DstPipe", func(t *testing.T) {
 			for _, newTest := range copyFileTests {
 				dst, src, data, hook, testName := newTest(t, 255)
 				dst.Close()

 				pr, pw, err := Pipe()
 				if err != nil {
 					t.Fatalf("%s: %v", testName, err)
 				}
 				defer pr.Close()
 				defer pw.Close()

 				n, err := io.Copy(pw, src)
 				if err != nil {
 					t.Fatalf("%s: %v", testName, err)
 				}
 				if n != int64(len(data)) {
 					t.Fatalf("%s: transferred %d, want %d", testName, n, len(data))
 				}
 				switch runtime.GOOS {
 				case "illumos":
 					// On illumos, We skip anything other than regular files conservatively
 					// for the target file, therefore the hook shouldn't have been called.
 					if hook.called {
 						t.Fatalf("%s: shouldn't have called the hook with a destination of pipe", testName)
 					}
 				default:
 					if !hook.called {
 						t.Fatalf("%s: should have called the hook with a destination of pipe", testName)
 					}
 				}
 				pw.Close()
 				mustContainData(t, pr, data)
 			}
 		})
 		t.Run("SrcPipe", func(t *testing.T) {
 			for _, newTest := range copyFileTests {
 				dst, src, data, hook, testName := newTest(t, 255)
 				src.Close()

 				pr, pw, err := Pipe()
 				if err != nil {
 					t.Fatalf("%s: %v", testName, err)
 				}
 				defer pr.Close()
 				defer pw.Close()

 				// The pipe is empty, and PIPE_BUF is large enough
 				// for this, by (POSIX) definition, so there is no
 				// need for an additional goroutine.
 				if _, err := pw.Write(data); err != nil {
 					t.Fatalf("%s: %v", testName, err)
 				}
 				pw.Close()

 				n, err := io.Copy(dst, pr)
 				if err != nil {
 					t.Fatalf("%s: %v", testName, err)
 				}
 				if n != int64(len(data)) {
 					t.Fatalf("%s: transferred %d, want %d", testName, n, len(data))
 				}
 				switch runtime.GOOS {
 				case "illumos", "solaris":
 					// On SunOS, We rely on File.Stat to get the size of the source file,
 					// which doesn't work for pipe.
 					if hook.called {
 						t.Fatalf("%s: shouldn't have called the hook with a source of pipe", testName)
 					}
 				default:
 					if !hook.called {
 						t.Fatalf("%s: should have called the hook with a source of pipe", testName)
 					}
 				}
 				mustSeekStart(t, dst)
 				mustContainData(t, dst, data)
 			}
 		})
 	})
 	t.Run("Nil", func(t *testing.T) {
 		var nilFile *File
 		anyFile, err := CreateTemp("", "")
 		if err != nil {
 			t.Fatal(err)
 		}
 		defer Remove(anyFile.Name())
 		defer anyFile.Close()

 		if _, err := io.Copy(nilFile, nilFile); err != ErrInvalid {
 			t.Errorf("io.Copy(nilFile, nilFile) = %v, want %v", err, ErrInvalid)
 		}
 		if _, err := io.Copy(anyFile, nilFile); err != ErrInvalid {
 			t.Errorf("io.Copy(anyFile, nilFile) = %v, want %v", err, ErrInvalid)
 		}
 		if _, err := io.Copy(nilFile, anyFile); err != ErrInvalid {
 			t.Errorf("io.Copy(nilFile, anyFile) = %v, want %v", err, ErrInvalid)
 		}

 		if _, err := nilFile.ReadFrom(nilFile); err != ErrInvalid {
 			t.Errorf("nilFile.ReadFrom(nilFile) = %v, want %v", err, ErrInvalid)
 		}
 		if _, err := anyFile.ReadFrom(nilFile); err != ErrInvalid {
 			t.Errorf("anyFile.ReadFrom(nilFile) = %v, want %v", err, ErrInvalid)
 		}
 		if _, err := nilFile.ReadFrom(anyFile); err != ErrInvalid {
 			t.Errorf("nilFile.ReadFrom(anyFile) = %v, want %v", err, ErrInvalid)
 		}
 	})
 }

 func testCopyFile(t *testing.T, dst, src *File, data []byte, hook *copyFileHook, limit int64, testName string) {
 	// If we have a limit, wrap the reader.
 	var (
 		realsrc io.Reader
 		lr      *io.LimitedReader
 	)
 	if limit >= 0 {
 		lr = &io.LimitedReader{N: limit, R: src}
 		realsrc = lr
 		if limit < int64(len(data)) {
 			data = data[:limit]
 		}
 	} else {
 		realsrc = src
 	}

 	// Now call ReadFrom (through io.Copy), which will hopefully call
 	// poll.CopyFileRange or poll.SendFile.
 	n, err := io.Copy(dst, realsrc)
 	if err != nil {
 		t.Fatalf("%s: %v", testName, err)
 	}

 	// If we didn't have a limit or had a positive limit, we should have called
 	// poll.CopyFileRange or poll.SendFile with the right file descriptor arguments.
 	if limit != 0 && !hook.called {
 		t.Fatalf("%s: never called the hook", testName)
 	}
 	if hook.called && hook.dstfd != int(dst.Fd()) {
 		t.Fatalf("%s: wrong destination file descriptor: got %d, want %d", testName, hook.dstfd, dst.Fd())
 	}
 	if hook.called && hook.srcfd != int(src.Fd()) {
 		t.Fatalf("%s: wrong source file descriptor: got %d, want %d", testName, hook.srcfd, src.Fd())
 	}

 	// Check that the offsets after the transfer make sense, that the size
 	// of the transfer was reported correctly, and that the destination
 	// file contains exactly the bytes we expect it to contain.
 	dstoff, err := dst.Seek(0, io.SeekCurrent)
 	if err != nil {
 		t.Fatalf("%s: %v", testName, err)
 	}
 	srcoff, err := src.Seek(0, io.SeekCurrent)
 	if err != nil {
 		t.Fatalf("%s: %v", testName, err)
 	}
 	if dstoff != srcoff {
 		t.Errorf("%s: offsets differ: dstoff = %d, srcoff = %d", testName, dstoff, srcoff)
 	}
 	if dstoff != int64(len(data)) {
 		t.Errorf("%s: dstoff = %d, want %d", testName, dstoff, len(data))
 	}
 	if n != int64(len(data)) {
 		t.Errorf("%s: short ReadFrom: wrote %d bytes, want %d", testName, n, len(data))
 	}
 	mustSeekStart(t, dst)
 	mustContainData(t, dst, data)

 	// If we had a limit, check that it was updated.
 	if lr != nil {
 		if want := limit - n; lr.N != want {
 			t.Fatalf("%s: didn't update limit correctly: got %d, want %d", testName, lr.N, want)
 		}
 	}
 }

 // mustContainData ensures that the specified file contains exactly the
 // specified data.
 func mustContainData(t *testing.T, f *File, data []byte) {
 	t.Helper()

 	got := make([]byte, len(data))
 	if _, err := io.ReadFull(f, got); err != nil {
 		t.Fatal(err)
 	}
 	if !bytes.Equal(got, data) {
 		t.Fatalf("didn't get the same data back from %s", f.Name())
 	}
 	if _, err := f.Read(make([]byte, 1)); err != io.EOF {
 		t.Fatalf("not at EOF")
 	}
 }

 func mustSeekStart(t *testing.T, f *File) {
 	if _, err := f.Seek(0, io.SeekStart); err != nil {
 		t.Fatal(err)
 	}
 }

 // newCopyFileTest initializes a new test for copying data between files.
 // It creates source and destination files, and populates the source file
 // with random data of the specified size, then rewind it, so it can be
 // consumed by copy_file_range(2) or sendfile(2).
 func newCopyFileTest(t *testing.T, size int64) (dst, src *File, data []byte) {
 	src, data = createTempFile(t, "test-copy-file-src", size)

 	dst, err := CreateTemp(t.TempDir(), "test-copy-file-dst")
 	if err != nil {
 		t.Fatal(err)
 	}
 	t.Cleanup(func() { dst.Close() })

 	return
 }

 type copyFileHook struct {
 	called bool
 	dstfd  int
 	srcfd  int

 	written int64
 	handled bool
 	err     error
 }

 func createTempFile(tb testing.TB, name string, size int64) (*File, []byte) {
 	f, err := CreateTemp(tb.TempDir(), name)
 	if err != nil {
 		tb.Fatalf("failed to create temporary file: %v", err)
 	}
 	tb.Cleanup(func() {
 		f.Close()
 	})

 	randSeed := time.Now().Unix()
 	tb.Logf("random data seed: %d\n", randSeed)
 	prng := rand.New(rand.NewSource(randSeed))
 	data := make([]byte, size)
 	prng.Read(data)
 	if _, err := f.Write(data); err != nil {
 		tb.Fatalf("failed to create and feed the file: %v", err)
 	}
 	if err := f.Sync(); err != nil {
 		tb.Fatalf("failed to save the file: %v", err)
 	}
 	if _, err := f.Seek(0, io.SeekStart); err != nil {
 		tb.Fatalf("failed to rewind the file: %v", err)
 	}

 	return f, data
 }
	// Copyright 2024 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	//go:build freebsd \|\| linux \|\| solaris

	package os_test

	import (
	"bytes"
	"io"
	"math/rand"
	. "os"
	"runtime"
	"strconv"
	"strings"
	"syscall"
	"testing"
	"time"
	)

	type (
	copyFileTestFunc func(testing.T, int64) (File, File, []byte, copyFileHook, string)
	copyFileTestHook func(testing.T) (copyFileHook, string)
	)

	func TestCopyFile(t *testing.T) {
	sizes := []int{
	1,
	42,
	1025,
	syscall.Getpagesize() + 1,
	32769,
	}
	t.Run("Basic", func(t *testing.T) {
	for _, size := range sizes {
	t.Run(strconv.Itoa(size), func(t *testing.T) {
	testCopyFiles(t, int64(size), -1)
	})
	}
	})
	t.Run("Limited", func(t *testing.T) {
	t.Run("OneLess", func(t *testing.T) {
	for _, size := range sizes {
	t.Run(strconv.Itoa(size), func(t *testing.T) {
	testCopyFiles(t, int64(size), int64(size)-1)
	})
	}
	})
	t.Run("Half", func(t *testing.T) {
	for _, size := range sizes {
	t.Run(strconv.Itoa(size), func(t *testing.T) {
	testCopyFiles(t, int64(size), int64(size)/2)
	})
	}
	})
	t.Run("More", func(t *testing.T) {
	for _, size := range sizes {
	t.Run(strconv.Itoa(size), func(t *testing.T) {
	testCopyFiles(t, int64(size), int64(size)+7)
	})
	}
	})
	})
	t.Run("DoesntTryInAppendMode", func(t *testing.T) {
	for _, newTest := range copyFileTests {
	dst, src, data, hook, testName := newTest(t, 42)

	dst2, err := OpenFile(dst.Name(), O_RDWR\|O_APPEND, 0755)
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	defer dst2.Close()

	if _, err := io.Copy(dst2, src); err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	switch runtime.GOOS {
	case "illumos", "solaris": // sendfile() on SunOS allows target file with O_APPEND set.
	if !hook.called {
	t.Fatalf("%s: should have called the hook even with destination in O_APPEND mode", testName)
	}
	default:
	if hook.called {
	t.Fatalf("%s: hook shouldn't be called with destination in O_APPEND mode", testName)
	}
	}
	mustSeekStart(t, dst2)
	mustContainData(t, dst2, data) // through traditional means
	}
	})
	t.Run("CopyFileItself", func(t *testing.T) {
	for _, hookFunc := range copyFileHooks {
	hook, testName := hookFunc(t)

	f, err := CreateTemp("", "file-readfrom-itself-test")
	if err != nil {
	t.Fatalf("%s: failed to create tmp file: %v", testName, err)
	}
	t.Cleanup(func() {
	f.Close()
	Remove(f.Name())
	})

	data := []byte("hello world!")
	if _, err := f.Write(data); err != nil {
	t.Fatalf("%s: failed to create and feed the file: %v", testName, err)
	}

	if err := f.Sync(); err != nil {
	t.Fatalf("%s: failed to save the file: %v", testName, err)
	}

	// Rewind it.
	if _, err := f.Seek(0, io.SeekStart); err != nil {
	t.Fatalf("%s: failed to rewind the file: %v", testName, err)
	}

	// Read data from the file itself.
	if _, err := io.Copy(f, f); err != nil {
	t.Fatalf("%s: failed to read from the file: %v", testName, err)
	}

	if hook.written != 0 \|\| hook.handled \|\| hook.err != nil {
	t.Fatalf("%s: File.readFrom is expected not to use any zero-copy techniques when copying itself."+
	"got hook.written=%d, hook.handled=%t, hook.err=%v; expected hook.written=0, hook.handled=false, hook.err=nil",
	testName, hook.written, hook.handled, hook.err)
	}

	switch testName {
	case "hookCopyFileRange":
	// For copy_file_range(2), it fails and returns EINVAL when the source and target
	// refer to the same file and their ranges overlap. The hook should be called to
	// get the returned error and fall back to generic copy.
	if !hook.called {
	t.Fatalf("%s: should have called the hook", testName)
	}
	case "hookSendFile", "hookSendFileOverCopyFileRange":
	// For sendfile(2), it allows the source and target to refer to the same file and overlap.
	// The hook should not be called and just fall back to generic copy directly.
	if hook.called {
	t.Fatalf("%s: shouldn't have called the hook", testName)
	}
	default:
	t.Fatalf("%s: unexpected test", testName)
	}

	// Rewind it.
	if _, err := f.Seek(0, io.SeekStart); err != nil {
	t.Fatalf("%s: failed to rewind the file: %v", testName, err)
	}

	data2, err := io.ReadAll(f)
	if err != nil {
	t.Fatalf("%s: failed to read from the file: %v", testName, err)
	}

	// It should wind up a double of the original data.
	if s := strings.Repeat(string(data), 2); s != string(data2) {
	t.Fatalf("%s: file contained %s, expected %s", testName, data2, s)
	}
	}
	})
	t.Run("NotRegular", func(t *testing.T) {
	t.Run("BothPipes", func(t *testing.T) {
	for _, hookFunc := range copyFileHooks {
	hook, testName := hookFunc(t)

	pr1, pw1, err := Pipe()
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	defer pr1.Close()
	defer pw1.Close()

	pr2, pw2, err := Pipe()
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	defer pr2.Close()
	defer pw2.Close()

	// The pipe is empty, and PIPE_BUF is large enough
	// for this, by (POSIX) definition, so there is no
	// need for an additional goroutine.
	data := []byte("hello")
	if _, err := pw1.Write(data); err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	pw1.Close()

	n, err := io.Copy(pw2, pr1)
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	if n != int64(len(data)) {
	t.Fatalf("%s: transferred %d, want %d", testName, n, len(data))
	}
	switch runtime.GOOS {
	case "illumos", "solaris":
	// On solaris, We rely on File.Stat to get the size of the source file,
	// which doesn't work for pipe.
	// On illumos, We skip anything other than regular files conservatively
	// for the target file, therefore the hook shouldn't have been called.
	if hook.called {
	t.Fatalf("%s: shouldn't have called the hook with a source or a destination of pipe", testName)
	}
	default:
	if !hook.called {
	t.Fatalf("%s: should have called the hook with both source and destination of pipe", testName)
	}
	}
	pw2.Close()
	mustContainData(t, pr2, data)
	}
	})
	t.Run("DstPipe", func(t *testing.T) {
	for _, newTest := range copyFileTests {
	dst, src, data, hook, testName := newTest(t, 255)
	dst.Close()

	pr, pw, err := Pipe()
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	defer pr.Close()
	defer pw.Close()

	n, err := io.Copy(pw, src)
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	if n != int64(len(data)) {
	t.Fatalf("%s: transferred %d, want %d", testName, n, len(data))
	}
	switch runtime.GOOS {
	case "illumos":
	// On illumos, We skip anything other than regular files conservatively
	// for the target file, therefore the hook shouldn't have been called.
	if hook.called {
	t.Fatalf("%s: shouldn't have called the hook with a destination of pipe", testName)
	}
	default:
	if !hook.called {
	t.Fatalf("%s: should have called the hook with a destination of pipe", testName)
	}
	}
	pw.Close()
	mustContainData(t, pr, data)
	}
	})
	t.Run("SrcPipe", func(t *testing.T) {
	for _, newTest := range copyFileTests {
	dst, src, data, hook, testName := newTest(t, 255)
	src.Close()

	pr, pw, err := Pipe()
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	defer pr.Close()
	defer pw.Close()

	// The pipe is empty, and PIPE_BUF is large enough
	// for this, by (POSIX) definition, so there is no
	// need for an additional goroutine.
	if _, err := pw.Write(data); err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	pw.Close()

	n, err := io.Copy(dst, pr)
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	if n != int64(len(data)) {
	t.Fatalf("%s: transferred %d, want %d", testName, n, len(data))
	}
	switch runtime.GOOS {
	case "illumos", "solaris":
	// On SunOS, We rely on File.Stat to get the size of the source file,
	// which doesn't work for pipe.
	if hook.called {
	t.Fatalf("%s: shouldn't have called the hook with a source of pipe", testName)
	}
	default:
	if !hook.called {
	t.Fatalf("%s: should have called the hook with a source of pipe", testName)
	}
	}
	mustSeekStart(t, dst)
	mustContainData(t, dst, data)
	}
	})
	})
	t.Run("Nil", func(t *testing.T) {
	var nilFile *File
	anyFile, err := CreateTemp("", "")
	if err != nil {
	t.Fatal(err)
	}
	defer Remove(anyFile.Name())
	defer anyFile.Close()

	if _, err := io.Copy(nilFile, nilFile); err != ErrInvalid {
	t.Errorf("io.Copy(nilFile, nilFile) = %v, want %v", err, ErrInvalid)
	}
	if _, err := io.Copy(anyFile, nilFile); err != ErrInvalid {
	t.Errorf("io.Copy(anyFile, nilFile) = %v, want %v", err, ErrInvalid)
	}
	if _, err := io.Copy(nilFile, anyFile); err != ErrInvalid {
	t.Errorf("io.Copy(nilFile, anyFile) = %v, want %v", err, ErrInvalid)
	}

	if _, err := nilFile.ReadFrom(nilFile); err != ErrInvalid {
	t.Errorf("nilFile.ReadFrom(nilFile) = %v, want %v", err, ErrInvalid)
	}
	if _, err := anyFile.ReadFrom(nilFile); err != ErrInvalid {
	t.Errorf("anyFile.ReadFrom(nilFile) = %v, want %v", err, ErrInvalid)
	}
	if _, err := nilFile.ReadFrom(anyFile); err != ErrInvalid {
	t.Errorf("nilFile.ReadFrom(anyFile) = %v, want %v", err, ErrInvalid)
	}
	})
	}

	func testCopyFile(t testing.T, dst, src File, data []byte, hook *copyFileHook, limit int64, testName string) {
	// If we have a limit, wrap the reader.
	var (
	realsrc io.Reader
	lr *io.LimitedReader
	)
	if limit >= 0 {
	lr = &io.LimitedReader{N: limit, R: src}
	realsrc = lr
	if limit < int64(len(data)) {
	data = data[:limit]
	}
	} else {
	realsrc = src
	}

	// Now call ReadFrom (through io.Copy), which will hopefully call
	// poll.CopyFileRange or poll.SendFile.
	n, err := io.Copy(dst, realsrc)
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}

	// If we didn't have a limit or had a positive limit, we should have called
	// poll.CopyFileRange or poll.SendFile with the right file descriptor arguments.
	if limit != 0 && !hook.called {
	t.Fatalf("%s: never called the hook", testName)
	}
	if hook.called && hook.dstfd != int(dst.Fd()) {
	t.Fatalf("%s: wrong destination file descriptor: got %d, want %d", testName, hook.dstfd, dst.Fd())
	}
	if hook.called && hook.srcfd != int(src.Fd()) {
	t.Fatalf("%s: wrong source file descriptor: got %d, want %d", testName, hook.srcfd, src.Fd())
	}

	// Check that the offsets after the transfer make sense, that the size
	// of the transfer was reported correctly, and that the destination
	// file contains exactly the bytes we expect it to contain.
	dstoff, err := dst.Seek(0, io.SeekCurrent)
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	srcoff, err := src.Seek(0, io.SeekCurrent)
	if err != nil {
	t.Fatalf("%s: %v", testName, err)
	}
	if dstoff != srcoff {
	t.Errorf("%s: offsets differ: dstoff = %d, srcoff = %d", testName, dstoff, srcoff)
	}
	if dstoff != int64(len(data)) {
	t.Errorf("%s: dstoff = %d, want %d", testName, dstoff, len(data))
	}
	if n != int64(len(data)) {
	t.Errorf("%s: short ReadFrom: wrote %d bytes, want %d", testName, n, len(data))
	}
	mustSeekStart(t, dst)
	mustContainData(t, dst, data)

	// If we had a limit, check that it was updated.
	if lr != nil {
	if want := limit - n; lr.N != want {
	t.Fatalf("%s: didn't update limit correctly: got %d, want %d", testName, lr.N, want)
	}
	}
	}

	// mustContainData ensures that the specified file contains exactly the
	// specified data.
	func mustContainData(t testing.T, f File, data []byte) {
	t.Helper()

	got := make([]byte, len(data))
	if _, err := io.ReadFull(f, got); err != nil {
	t.Fatal(err)
	}
	if !bytes.Equal(got, data) {
	t.Fatalf("didn't get the same data back from %s", f.Name())
	}
	if _, err := f.Read(make([]byte, 1)); err != io.EOF {
	t.Fatalf("not at EOF")
	}
	}

	func mustSeekStart(t testing.T, f File) {
	if _, err := f.Seek(0, io.SeekStart); err != nil {
	t.Fatal(err)
	}
	}

	// newCopyFileTest initializes a new test for copying data between files.
	// It creates source and destination files, and populates the source file
	// with random data of the specified size, then rewind it, so it can be
	// consumed by copy_file_range(2) or sendfile(2).
	func newCopyFileTest(t testing.T, size int64) (dst, src File, data []byte) {
	src, data = createTempFile(t, "test-copy-file-src", size)

	dst, err := CreateTemp(t.TempDir(), "test-copy-file-dst")
	if err != nil {
	t.Fatal(err)
	}
	t.Cleanup(func() { dst.Close() })

	return
	}

	type copyFileHook struct {
	called bool
	dstfd int
	srcfd int

	written int64
	handled bool
	err error
	}

	func createTempFile(tb testing.TB, name string, size int64) (*File, []byte) {
	f, err := CreateTemp(tb.TempDir(), name)
	if err != nil {
	tb.Fatalf("failed to create temporary file: %v", err)
	}
	tb.Cleanup(func() {
	f.Close()
	})

	randSeed := time.Now().Unix()
	tb.Logf("random data seed: %d\n", randSeed)
	prng := rand.New(rand.NewSource(randSeed))
	data := make([]byte, size)
	prng.Read(data)
	if _, err := f.Write(data); err != nil {
	tb.Fatalf("failed to create and feed the file: %v", err)
	}
	if err := f.Sync(); err != nil {
	tb.Fatalf("failed to save the file: %v", err)
	}
	if _, err := f.Seek(0, io.SeekStart); err != nil {
	tb.Fatalf("failed to rewind the file: %v", err)
	}

	return f, data
	}