// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build js

package net

import (
	"os"
	"syscall"
)

func fileConn(f *os.File) (Conn, error)             { return nil, syscall.ENOPROTOOPT }
func fileListener(f *os.File) (Listener, error)     { return nil, syscall.ENOPROTOOPT }

				t.Error(perr)
			}
			t.Fatal(err)
		}

		c2, err := FileConn(f)
		if err := f.Close(); err != nil {
			t.Error(err)
		}
		if err != nil {
			if perr := parseCommonError(err); perr != nil {
				t.Error(perr)
			}
			t.Fatal(err)
		}
		defer c2.Close()

		if _, err := c2.Write([]byte("FILECONN TEST")); err != nil {
			if perr := parseWriteError(err); perr != nil {

	raddr := fd.addrFunc()(rsa)
	fd.net = laddr.Network()
	if err := fd.init(); err != nil {
		fd.Close()
		return nil, err
	}
	fd.setAddr(laddr, raddr)
	return fd, nil
}

func fileConn(f *os.File) (Conn, error) {
	fd, err := newFileFD(f)
	if err != nil {
		return nil, err
	}
	switch fd.laddr.(type) {
	case *TCPAddr:

	}
	dir := netdir + "/" + comp[1] + "/" + name
	laddr, err := readPlan9Addr(comp[1], dir+"/local")
	if err != nil {
		return nil, err
	}
	return newFD(comp[1], name, nil, ctl, nil, laddr, nil)
}

func fileConn(f *os.File) (Conn, error) {
	fd, err := newFileFD(f)
	if err != nil {
		return nil, err
	}
	if !fd.ok() {
		return nil, syscall.EINVAL
	}

	fd.data, err = os.OpenFile(fd.dir+"/data", os.O_RDWR, 0)

func startTestSocketPeer(t testing.TB, conn Conn, op string, chunkSize, totalSize int) (func(t testing.TB), error) {
	t.Helper()

	if runtime.GOOS == "windows" {
		// TODO(panjf2000): Windows has not yet implemented FileConn,
		//		remove this when it's implemented in https://go.dev/issues/9503.
		t.Fatalf("startTestSocketPeer is not supported on %s", runtime.GOOS)
	}

	f, err := conn.(interface{ File() (*os.File, error) }).File()

	}

	f, err := os.CreateTemp("", "go-nettest")
	if err != nil {
		t.Fatal(err)
	}
	defer os.Remove(f.Name())
	defer f.Close()

	c, err := FileConn(f)
	if err != nil {
		if c != nil {
			t.Errorf("FileConn returned non-nil interface %T(%v) with err != nil", c, c)
		}
		if perr := parseCommonError(err); perr != nil {
			t.Error(perr)
		}
	} else {
		c.Close()

		b.Fatalf("expected %d copied bytes, but got %d", dataSize, n)
	}

	cancel()
}

func BenchmarkSendFile(b *testing.B) {
	if runtime.GOOS == "windows" {
		// TODO(panjf2000): Windows has not yet implemented FileConn,
		//		remove this when it's implemented in https://go.dev/issues/9503.
		b.Skipf("skipping on %s", runtime.GOOS)
	}

	b.Run("file-to-tcp", func(b *testing.B) { benchmarkSendFile(b, "tcp") })

        then:
        0 * writerContextMock._
    }

    def testWriteNoneNullValue() throws IOException {
        final File fileOne = new File("fileOne")
        final File fileTwo = new File("fileTwo")

        pathOption.getValue().add(fileOne)
        pathOption.getValue().add(fileTwo)

        when:
        pathOption.write(writerContextMock)

        then:

    }

    def "serializes state with shared include files"() {
        when:
        def fileOne = new File("one")
        def fileStates = [:]
        def stateOne = compilationFileState(TestHashCodes.hashCodeFrom(0x12345678), ["ONE", "TWO"])
        fileStates.put(fileOne, stateOne)

        def fileTwo = new File("two")

		{"Dialer.LocalAddr", Field, 1},
		{"Dialer.Resolver", Field, 8},
		{"Dialer.Timeout", Field, 1},
		{"ErrClosed", Var, 16},
		{"ErrWriteToConnected", Var, 0},
		{"Error", Type, 0},
		{"FileConn", Func, 0},
		{"FileListener", Func, 0},
		{"FilePacketConn", Func, 0},
		{"FlagBroadcast", Const, 0},
		{"FlagLoopback", Const, 0},
		{"FlagMulticast", Const, 0},
		{"FlagPointToPoint", Const, 0},