counter.write(data);
    written += 10;
    assertEquals(written, out.size());
    assertEquals(written, counter.getCount());

    counter.write(data, 0, 5);
    written += 5;
    assertEquals(written, out.size());
    assertEquals(written, counter.getCount());

    counter.write(data, 2, 5);
    written += 5;
    assertEquals(written, out.size());
    assertEquals(written, counter.getCount());

        write(original)

        expect:
        original == written
    }

    def "serializes string properties"() {
        def original = string("x")
        write(original)

        expect:
        original == written
    }

    def "serializes number properties"() {
        write(value)

        expect:
        value == written

        where:
        value                                   | _

		written += int64(n)
		if err != nil {
			return written, err
		}

		n, err = fmt.Fprintf(bw, "%d %d\n", edge.CallSiteOffset, weight)
		written += int64(n)
		if err != nil {
			return written, err
		}
	}

	if err := bw.Flush(); err != nil {
		return written, err
	}

	// No need to serialize TotalWeight, it can be trivially recomputed
	// during parsing.

	return written, nil

	expectedStatusCode := 201
	assert.False(t, trw.written, "Written field originally false in delegate response writer")
	trw.WriteHeader(expectedStatusCode)
	assert.Equal(t, expectedStatusCode, trw.w.(*mockResponseWriter).statusCode, "Expected written status code is correct")
	assert.True(t, trw.written, "Written field set to true after writing delegate response writer")
	// Response writer already written to does not write status.

     */
    void skipBytes(long count) throws EOFException, IOException;

    /**
     * Reads a byte stream written using {@link Encoder#encodeChunked(Encoder.EncodeAction)}.
     */
    <T> T decodeChunked(DecodeAction<Decoder, T> decodeAction) throws EOFException, Exception;

    /**

			w := LimitWriter(output, test.limit)

			var (
				err     error
				written int64
				n       int
			)
			for written < test.inputSize && err == nil {
				n, err = w.Write(input[written : written+test.writeSize])
				written += int64(n)
			}

			expectWritten := bounded(0, test.inputSize, test.limit)
			assert.EqualValues(t, expectWritten, written)
			if expectWritten <= 0 {
				assert.Empty(t, output)
			} else {

		s = v.fd
	case *UnixConn:
		if v.fd.net != "unix" {
			return 0, nil, false
		}
		s = v.fd
	default:
		return 0, nil, false
	}

	written, handled, err = pollSplice(&c.pfd, &s.pfd, remain)
	if lr != nil {
		lr.N -= written
	}
	return written, wrapSyscallError("splice", err), handled
}

// spliceTo transfers data from c to w using the splice system call to minimize

package poll

import (
	"io"
	"syscall"
)

// SendFile wraps the TransmitFile call.
func SendFile(fd *FD, src syscall.Handle, n int64) (written int64, err error) {
	defer func() {
		TestHookDidSendFile(fd, 0, written, err, written > 0)
	}()
	if fd.kind == kindPipe {
		// TransmitFile does not work with pipes
		return 0, syscall.ESPIPE
	}

! stdout ^ok
! stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithTestdata[/\\]'
stdout 'failure while testing seed corpus entry: FuzzWithTestdata/1'
stdout FAIL

# Test that fuzzing a target with no seed corpus or cache finds a crash, prints
# it, and write it to testdata
! go test -fuzz=FuzzWithNoCache -run=FuzzWithNoCache -fuzztime=1x
! stdout ^ok
stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithNoCache[/\\]'

	if pfd == nil || !pfd.IsStream {
		return
	}

	written, handled, err = pollSplice(&f.pfd, pfd, remain)

	if lr != nil {
		lr.N = remain - written
	}

	return written, handled, wrapSyscallError("splice", err)
}

func (f *File) copyFileRange(r io.Reader) (written int64, handled bool, err error) {
	var (
		remain int64
		lr     *io.LimitedReader
	)