def localCache = new TestBuildCache(file("local-cache"))
        settingsFile << localCache.localCacheConfiguration()

        when:
        remote("throw new ${exceptionType.name}('!')", "writer.writeTo(${NullOutputStream.name}.INSTANCE)")
        settingsFile << """
            buildCache { remote($remoteCacheClass) }
        """
        buildFile << cacheableTask() << """
            apply plugin: "base"

            Template template = templateEngine.createTemplate(templateText);
            try (Writer writer = Files.asCharSink(target, Charsets.UTF_8, FileWriteMode.APPEND).openStream()) {
                template.make(bindings).writeTo(writer);
            }
        } catch (Exception ex) {
            throw new GradleException("Could not generate file " + target + ".", ex);
        }
    }

        then:
        ! found
        1 * delegate.get(hashCode) >> null
        0 * _
    }

    def "can write to map"() {
        when:
        cache.store(cacheKey, writer)
        then:
        1 * writer.writeTo(_) >> { OutputStream output ->
            output.write(data)
        }
        1 * delegate.put(hashCode, _) >> { String key, byte[] value ->
            assert value == data
        }

    ) {
        this.buildInvocationScopeId = buildInvocationScopeId;
        this.checksumService = checksumService;
    }

    public void writeTo(Writer writer, ModuleMetadataSpec metadata) throws IOException {

        // Write the output
        JsonWriter jsonWriter = new JsonWriter(writer);
        jsonWriter.setHtmlSafe(false);
        jsonWriter.setIndent("  ");

        new ModuleMetadataJsonWriter(
            jsonWriter,

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

//go:build !linux

package os

import "io"

func (f *File) writeTo(w io.Writer) (written int64, handled bool, err error) {
	return 0, false, nil
}

func (f *File) readFrom(r io.Reader) (n int64, handled bool, err error) {
	return 0, false, nil

func (noBody) Read([]byte) (int, error)         { return 0, io.EOF }
func (noBody) Close() error                     { return nil }
func (noBody) WriteTo(io.Writer) (int64, error) { return 0, nil }

var (
	// verify that an io.Copy from NoBody won't require a buffer:
	_ io.WriterTo   = NoBody
	_ io.ReadCloser = NoBody
)

// PushOptions describes options for [Pusher.Push].
type PushOptions struct {

        }

        destFile.parentFile.mkdirs()
        destFile.withWriter { Writer writer ->
            if (templateName.endsWith('.gradle')) {
                writer << "// Generated for subproject ${templateArgs.projectName}\n"
            }
            getTemplate(templateFiles.last()).make(templateArgs).writeTo(writer)
        }
    }

    def getTemplate(File srcTemplate) {

     */
    boolean readFrom(Object path);

    /**
     * Writes the deployment descriptor into a writer.
     *
     * @param writer
     *            The writer to write the deployment descriptor to
     * @return this
     */
    DeploymentDescriptor writeTo(Writer writer);

    /**
     * Writes the deployment descriptor into a file. The paths are resolved as defined by

		t.Fatalf("NewWriter: %v", err)
	}
	flushErr := zw.Flush()
	closeErr := zw.Close()
	_, writeErr := zw.Write([]byte("Test"))
	checkErrors([]error{closeErr, flushErr, writeErr}, errIO, t)
}

func TestWriterPersistentCloseError(t *testing.T) {
	// If underlying writer return error on closing stream we should persistent this error across all writer calls.
	zw, err := NewWriter(&failWriter{0}, DefaultCompression)
	if err != nil {

		r := NewReader(rw)
		if _, err := r.WriteTo(rw); err != rw.expected {
			t.Errorf("r.WriteTo(errorWriterToTests[%d]) = _, %v, want _,%v", i, err, rw.expected)
		}
	}
}

func TestWriterReadFrom(t *testing.T) {
	ws := []func(io.Writer) io.Writer{
		func(w io.Writer) io.Writer { return onlyWriter{w} },
		func(w io.Writer) io.Writer { return w },
	}

	rs := []func(io.Reader) io.Reader{