if (!schema_parse_result) {
    std::cerr << "Parse error.\n";
    return 1;
  }
  const size_t length = parser.builder_.GetSize();
  const size_t n =
      std::fwrite(parser.builder_.GetBufferPointer(), 1, length, stdout);
  if (n != length) {
    std::cerr << "print to stdout filed.\n";
    return 1;
  }
  return 0;

        writer.startElement(VERIFY_SIGNATURES);
        writer.write(String.valueOf(configuration.isVerifySignatures()));
        writer.endElement();
    }

    private void writeVerifyMetadata(DependencyVerificationConfiguration configuration) throws IOException {
        writer.startElement(VERIFY_METADATA);
        writer.write(String.valueOf(configuration.isVerifyMetadata()));

                writer.endElement();
            }

            if (options.includeSystemErrLog && outputProvider.has(TestOutputEvent.Destination.StdErr)) {
                writer.startElement("system-err");
                writer.startCDATA();
                outputProvider.write(TestOutputEvent.Destination.StdErr, writer);
                writer.endCDATA();
                writer.endElement();
            }

            writer.println("    private static final String MIN_SUPPORTED_GRADLE_VERSION = \"5.0\";");
            writer.println("    @Override");
            writer.println("    public void apply(" + targetClass + " target) {");
            writer.println("        assertSupportedByCurrentGradleVersion();");
            writer.println("        try {");
            writer.println(firstPassCode);
            writer.println();

                }

                artifactViewFiles.each {
                    writeFile("artifact-view-file", writer, it)
                }
                artifactViewArtifacts.each {
                    writeArtifact("artifact-view-artifact", writer, it)
                }
                artifactViewFiles.files.each {
                    writeFile("artifact-view-file-file", writer, it)
                }

        try {
            try (PrintWriter writer = new PrintWriter(new FileWriter(file))) {
                writer.println("#");
                writer.println("# https://help.github.com/articles/dealing-with-line-endings/");
                writer.println("#");
                writer.println("# Linux start script should use lf");
                writer.println("/gradlew        text eol=lf");
                writer.println();

	//   In logd mode: "<android_log_header_t 11 bytes><priority 1 byte><tag n bytes>"
	//
	// The entire log needs to be delivered in a single syscall (the NDK
	// does this with writev). Each log is its own line, so we need to
	// buffer writes until we see a newline.
	var hlen int
	switch logger {
	case logd:
		hlen = writeLogdHeader()
	case legacy:
		hlen = len(writeHeader)
	}

	dst := writeBuf[hlen:]

        final int result = copy(url, "UTF-8", writer);
        assertThat(result, is(urlString.length()));
        assertThat(writer.toString(), is(urlString));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testFileToWriter() throws Exception {
        final int result = copy(inputFile, "UTF-8", writer);
        assertThat(result, is(urlString.length()));

        try {
            try (PrintWriter writer = new PrintWriter(rootDir.file("build.gradle"))) {
                writer.println("apply plugin: 'java'");
                writer.println(String.format("dependencies { %s gradleApi() }", conf));
                writer.println("jar {");
                if (shouldPreserveTimestamps != null) {

// executes at least one write operation if it is closed.
//
// This can be useful within the context of HTTP. At least
// one write operation must happen to send the HTTP headers
// to the peer.
type WriteOnCloser struct {
	io.Writer
	hasWritten bool
}

func (w *WriteOnCloser) Write(p []byte) (int, error) {
	w.hasWritten = true
	return w.Writer.Write(p)
}