public long getContentLength() {
                return writer.getSize();
            }

            @Override
            public InputStream getContent() {
                throw new UnsupportedOperationException();
            }

            @Override
            public void writeTo(OutputStream outstream) throws IOException {
                writer.writeTo(outstream);
            }

            @Override

}

func TestWriteAfterWriterClose(t *testing.T) {
	r, w := Pipe()
	defer r.Close()
	done := make(chan bool)
	var writeErr error
	go func() {
		_, err := w.Write([]byte("hello"))
		if err != nil {
			t.Errorf("got error: %q; expected none", err)
		}
		w.Close()
		_, writeErr = w.Write([]byte("world"))
		done <- true
	}()

	buf := make([]byte, 100)
	var result string
	n, err := ReadFull(r, buf)

Joe Tsai <******@****.***> 1503105518 -0700

     *
     * @param output output stream to write build cache entry to
     * @throws IOException when an I/O error occurs when writing the cache entry to the given output stream
     */
    void writeTo(OutputStream output) throws IOException;

    /**
     * Returns the size of the build cache entry to be written.
     *
     * @return the size of the build cache entry to be written.
     * @since 4.1
     */

type JSONPrinter struct{}

// PrintObj is an implementation of ResourcePrinter.PrintObj which simply writes the object to the Writer.
func (p *JSONPrinter) PrintObj(obj runtime.Object, w io.Writer) error {
	// we use reflect.Indirect here in order to obtain the actual value from a pointer.
	// we need an actual value in order to retrieve the package path for an object.

		}
		defer func() {
			tf.Close()
			os.Remove("templateFile")
		}()
		_, err = tf.Write(templateBytes)
		if err != nil {
			return
		}

		// call target
		var buf bytes.Buffer
		i.WriteTo("templateFile", io.Writer(&buf))
	})

        server.expectGetEmptyOk("/redirect/cache/${key.hashCode}")

        when:
        def writer = writer(content)
        cache.store(key, writer)

        then:
        noExceptionThrown()
        writer.writeCount == 1
    }

    def "storing to cache can follow method preserving redirects"() {
        def destFile = tempDir.file("cached.zip")

func RenderHTML(w http.ResponseWriter, t *template.Template, data any) {
	b := &bytes.Buffer{}

	if err := t.Execute(b, data); err != nil {
		RenderError(w, http.StatusInternalServerError, err)
		return
	}

	w.WriteHeader(http.StatusOK)
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	_, _ = b.WriteTo(w)
}

// RenderJSON outputs the given data as JSON

                        original.close();
                    }
                    StringWriter writer = new StringWriter();
                    // SimpleTemplateEngine expects to be able to mutate the map internally.
                    template.make(new LinkedHashMap<>(properties)).writeTo(writer);
                    return new StringReader(writer.toString());
                } catch (MissingPropertyException e) {

                                version v.availableAt.version
                            }
                        }
                    }
                }
            })
        }
        jsonBuilder.writeTo(writer)
    }