func (e *DeadlineExceededError) Timeout() bool   { return true }
func (e *DeadlineExceededError) Temporary() bool { return true }

// ErrNotPollable is returned when the file or socket is not suitable
// for event notification.
var ErrNotPollable = errors.New("not pollable")

// consume removes data from a slice of byte slices, for writev.
func consume(v *[][]byte, n int64) {
	for len(*v) > 0 {

// license that can be found in the LICENSE file.

package poll_test

import (
	"fmt"
	"io/fs"
	"net"
	"os"
	"testing"
	"time"
)

func TestReadError(t *testing.T) {
	t.Run("ErrNotPollable", func(t *testing.T) {
		f, err := badStateFile()
		if err != nil {
			t.Skip(err)
		}
		defer f.Close()

		// Give scheduler a chance to have two separated

	// configured in halfway.
	return os.OpenFile("/dev/net/tun", os.O_RDWR, 0)
}

func isBadStateFileError(err error) (string, bool) {
	switch err {
	case poll.ErrNotPollable, syscall.EBADFD:
		return "", true
	default:
		return "not pollable or file in bad state error", false
	}

	switch res {
	case pollNoError:
		return nil
	case pollErrClosing:
		return errClosing(isFile)
	case pollErrTimeout:
		return ErrDeadlineExceeded
	case pollErrNotPollable:
		return ErrNotPollable
	}
	println("unreachable: ", res)
	panic("unreachable")
}

// SetDeadline sets the read and write deadlines associated with fd.
func (fd *FD) SetDeadline(t time.Time) error {

		return nil
	}
	switch err := nestedErr.(type) {
	case *os.SyscallError:
		nestedErr = err.Err
		goto third
	}
	switch nestedErr {
	case ErrClosed, errTimeout, poll.ErrNotPollable, os.ErrDeadlineExceeded:
		return nil
	}
	return fmt.Errorf("unexpected type on 2nd nested level: %T", nestedErr)

third:
	if isPlatformError(nestedErr) {
		return nil
	}