// Splice cannot continue.
		//
		// If inPipe == 0 && err == nil, src is at EOF, and the
		// transfer is complete.
		handled = handled || (err != syscall.EINVAL)
		if err != nil || inPipe == 0 {
			break
		}
		p.data += inPipe

		n, err = splicePump(dst, p.rfd, inPipe)
		if n > 0 {
			written += int64(n)
			remain -= int64(n)
			p.data -= n
		}
	}
	if err != nil {
		return written, handled, err
	}

limitations under the License.
*/

package util

import (
	"fmt"
	"path/filepath"
	"strings"
	"syscall"
	"time"
)

const npipeProtocol = "npipe"

// LocalEndpoint returns the full path to a named pipe at the given endpoint - unlike on unix, we can't use sockets.
func LocalEndpoint(path, file string) (string, error) {

import (
	"log"
	"os"
	"runtime/trace"
	"syscall"
	"time"
)

func main() {
	// Create a pipe to block on.
	var p [2]int
	if err := syscall.Pipe(p[:]); err != nil {
		log.Fatalf("failed to create pipe: %v", err)
	}
	rfd, wfd := p[0], p[1]

	// Create a goroutine that blocks on the pipe.
	done := make(chan struct{})
	go func() {
		var data [1]byte
		_, err := syscall.Read(rfd, data[:])

	for i := 0; i < N; i++ {
		p, err = poll.GetPipe()
		if err != nil {
			t.Skipf("failed to create pipe due to error(%v), skip this test", err)
		}
		_, pwfd := poll.GetPipeFds(p)
		allFDs = append(allFDs, pwfd)
		pendingFDs.Store(pwfd, struct{}{})
		ps = append(ps, p)
	}
	for _, p = range ps {
		poll.PutPipe(p)
	}
	ps = nil
	p = nil

	// Exploit the timeout of "go test" as a timer for the subsequent verification.

	defer func() {
		TestHookDidSendFile(fd, 0, written, err, written > 0)
	}()
	if fd.kind == kindPipe {
		// TransmitFile does not work with pipes
		return 0, syscall.ESPIPE
	}
	if ft, _ := syscall.GetFileType(src); ft == syscall.FILE_TYPE_PIPE {
		return 0, syscall.ESPIPE
	}

	if err := fd.writeLock(); err != nil {
		return 0, err
	}
	defer fd.writeUnlock()

	o := &fd.wop
	o.handle = src

  // content.
  //
  // Unlike wcscmp(), this function can handle NULL argument(s).  A
  // NULL C string is considered different to any non-NULL C string,
  // including the empty string.
  static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);

  // Compares two C strings, ignoring case.  Returns true iff they
  // have the same content.
  //

	syscall_TCP_KEEPCNT   = windows.TCP_KEEPCNT
	syscall_TCP_KEEPINTVL = windows.TCP_KEEPINTVL
)

type fdType = syscall.Handle

func maybeSkipKeepAliveTest(t *testing.T) {
	// TODO(panjf2000): Unlike Unix-like OS's, old Windows (prior to Windows 10, version 1709)
	// 	doesn't provide any ways to retrieve the current TCP keep-alive settings, therefore
	// 	we're not able to run the test suite similar to Unix-like OS's on Windows.

	}{
		{
			path:             "/var/lib/kubelet/pod-resources",
			file:             "kube.sock", // this is not the default, but it's not relevant here
			expectError:      false,
			expectedFullPath: `npipe://\\.\pipe\kubelet-pod-resources`,
		},
	}
	for _, test := range tests {
		fullPath, err := LocalEndpoint(test.path, test.file)
		if test.expectError {
			assert.NotNil(t, err, "expected error")
			continue
		}

	}
	if isData {
		j.symType = "DATA"
	}

	var err error
	if j.in, err = j.cmd.StdinPipe(); err != nil {
		return nil, err
	}

	outPipe, err := j.cmd.StdoutPipe()
	if err != nil {
		return nil, err
	}

	j.out = bufio.NewReader(outPipe)
	if err := j.cmd.Start(); err != nil {
		return nil, err
	}

	a := &llvmSymbolizer{
		filename: file,
		rw:       j,
		base:     base,
	}

 * limitations under the License.
 *
 */
package mockwebserver3

import java.io.IOException
import okhttp3.ExperimentalOkHttpApi
import okio.BufferedSink

/**
 * The body of a [MockResponse].
 *
 * Unlike [okhttp3.ResponseBody], this interface is designed to be implemented by writers and not
 * called by readers.
 */
@ExperimentalOkHttpApi
interface MockResponseBody {