)

// DrainBody close non nil response with any response Body.
// convenient wrapper to drain any remaining data on response body.
//
// Subsequently this allows golang http RoundTripper
// to reuse the same connection for future requests.
func DrainBody(respBody io.ReadCloser) {
	// Callers should close resp.Body when done reading from it.
	// If resp.Body is not closed, the Client's underlying RoundTripper

        homeDirServices.release(services1)

        then:
        !homeDir2Service.closed
        !homeDir1Service.closed

        when:
        homeDirServices.release(services2)

        then:
        homeDir2Service.closed
        !homeDir1Service.closed
    }

    def "closes services when registry closed"() {
        def dir = new File("home-dir")

        given:

        0 * opened._

        when:
        factory.close()

        then:
        1 * closed.accept(implementation)
        0 * _
    }

    void "closes cache instance when reference is closed"() {
        def implementation

        when:
        def cache1 = factory.open(tmpDir.testDirectory, null, [prop: 'value'], mode(Exclusive), null, null)

// arrives or the write end is closed.
// If the write end is closed with an error, that error is
// returned as err; otherwise err is EOF.
func (r *PipeReader) Read(data []byte) (n int, err error) {
	return r.pipe.read(data)
}

// Close closes the reader; subsequent writes to the
// write half of the pipe will return the error [ErrClosedPipe].
func (r *PipeReader) Close() error {
	return r.CloseWithError(nil)
}

        then:
        input.closed
    }

    def "closes input on subsequent use"() {
        given:
        def input = new TestInputStream()

        when:
        target.readFrom(new ByteArrayInputStream([] as byte[]))
        target.readFrom(input)

        then:
        thrown IllegalStateException
        input.closed
    }

    def "closes input on error"() {
        given:

        boolean closed
        boolean error

        @Override
        void write(int b) throws IOException {
            if (error) {
                throw new IOException("bang!")
            }
        }

        @Override
        void close() throws IOException {
            closed = true
        }
    }

    def "closes output"() {
        given:

	if n != len(src) && err == nil { // should never happen
		err = io.ErrShortWrite
	}
	return
}

// Close closes the underlying Writer and returns its Close return value, if the Writer
// is also an io.Closer. Otherwise it returns nil.
func (w StreamWriter) Close() error {
	if c, ok := w.W.(io.Closer); ok {
		return c.Close()
	}
	return nil

    }

    public void close() {
        closed = true;
    }

    public Action<Object> closer() {
        return new Action<Object>() {
            @Override
            public void execute(Object o) {
                close();
            }
        };
    }

    @Override
    public void assertCanMutate() {
        if (closed) {

        return result;
    }

    /**
     * Closes the given resource rethrowing any {@link IOException} as a {@link UncheckedIOException}.
     *
     * @param resource The resource to be closed
     */
    public static void uncheckedClose(@Nullable Closeable resource) {
        try {
            if (resource != null) {
                resource.close();
            }
        } catch (IOException e) {

    }

    /**
     * Closes this output stream and releases any system resources associated with this stream. The general contract of
     * <code>close</code> is that it closes the output stream. A closed stream cannot perform output operations and
     * cannot be reopened.
     */
    @Override
    public void close() throws IOException {
        hasBeenClosed = true;
        flush();