def stream = new ByteArrayOutputStream()
        def result = resource.writeTo(stream)
        result.bytesRead == 4
        stream.toString() == "1234"

        file.setText("abc")
        def stream2 = new ByteArrayOutputStream()
        def result2 = resource.writeTo(stream2)
        result2.bytesRead == 3
        stream2.toString() == "abc"
    }

                if (details.key == 'foo') {
                    details.exclude()
                }
            }
        }
    }
}
// end::merge[]

// tag::write[]
tasks.named('jar') { manifest.writeTo(layout.buildDirectory.file('mymanifest.mf')) }

                }
                if (key == "foo") {
                    exclude()
                }
            })
        }
    }
}
// end::merge[]

// tag::write[]
tasks.jar { manifest.writeTo(layout.buildDirectory.file("mymanifest.mf")) }

    }

    public String asString() {
        StringWriter string = new StringWriter();
        writeTo(new PrintWriter(string));
        return string.toString();
    }

    public void writeTo(PrintWriter writer) {

        @Override public long contentLength() {
          return -1; // We don't know the compressed length in advance!
        }

        @Override public void writeTo(BufferedSink sink) throws IOException {
          BufferedSink gzipSink = Okio.buffer(new GzipSink(sink));
          body.writeTo(gzipSink);
          gzipSink.close();
        }
      };
    }
  }

	return 0, nil, syscall.EPLAN9
}

func (c *UnixConn) readMsg(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error) {
	return 0, 0, 0, nil, syscall.EPLAN9
}

func (c *UnixConn) writeTo(b []byte, addr *UnixAddr) (int, error) {
	return 0, syscall.EPLAN9
}

func (c *UnixConn) writeMsg(b, oob []byte, addr *UnixAddr) (n, oobn int, err error) {
	return 0, 0, syscall.EPLAN9
}

}

func (fdmu *FDMutex) ReadLock() bool {
	return fdmu.fdmu.rwlock(true)
}

func (fdmu *FDMutex) ReadUnlock() bool {
	return fdmu.fdmu.rwunlock(true)
}

func (fdmu *FDMutex) WriteLock() bool {
	return fdmu.fdmu.rwlock(false)
}

func (fdmu *FDMutex) WriteUnlock() bool {
	return fdmu.fdmu.rwunlock(false)

        HttpGet request = new HttpGet(url);
        try {
            HttpEntity entity = doGet(request);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            entity.writeTo(baos);
            return baos.toByteArray();
        } catch (Exception e) {
            ExceptionUtils.rethrow(e); // this dependency is internal only
        } finally {
            request.releaseConnection();

 * called by readers.
 */
@ExperimentalOkHttpApi
interface MockResponseBody {
  /** The length of this response in bytes, or -1 if unknown. */
  val contentLength: Long

  @Throws(IOException::class)
  fun writeTo(sink: BufferedSink)

func SendFile(dstFD *FD, src int, pos, remain int64) (written int64, err error, handled bool) {
	defer func() {
		TestHookDidSendFile(dstFD, src, written, err, handled)
	}()
	if err := dstFD.writeLock(); err != nil {
		return 0, err, false
	}
	defer dstFD.writeUnlock()

	if err := dstFD.pd.prepareWrite(dstFD.isFile); err != nil {
		return 0, err, false
	}

	dst := dstFD.Sysfd
	for remain > 0 {