// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package bio

import (
	"io"
	"log"
)

// MustClose closes Closer c and calls log.Fatal if it returns a non-nil error.
func MustClose(c io.Closer) {
	if err := c.Close(); err != nil {
		log.Fatal(err)
	}
}

// MustWriter returns a Writer that wraps the provided Writer,

// It returns an error when fd cannot be used.
func (fd *FD) incref() error {
	if !fd.fdmu.incref() {
		return errClosing(fd.isFile)
	}
	return nil
}

// decref removes a reference from fd.
// It also closes fd when the state of fd is set to closed and there
// is no remaining reference.
func (fd *FD) decref() error {
	if fd.fdmu.decref() {
		return fd.destroy()
	}
	return nil
}

    /**
     * Opens this cache access instance when the cache is opened. State lock is held while this method is called.
     */
    public abstract void open();

    /**
     * Closes this cache access instance when the cache is opened. State lock is held while this method is called.
     */
    @Override
    public abstract void close();

import org.gradle.cache.IndexedCacheParameters;

import java.io.Closeable;

public interface CacheCreationCoordinator extends Closeable, HasCleanupAction {
    void open();

    /**
     * Closes the cache, blocking until all operations have completed.
     */
    @Override
    void close();

    <K, V> IndexedCache<K, V> newCache(IndexedCacheParameters<K, V> parameters);

- *If total drives has many common divisors the algorithm chooses the minimum amounts of erasure sets possible for a erasure set size of any N*.  In the example with 1024 drives - 4, 8, 16 are GCD factors. With 16 drives we get a total of 64 possible sets, with 8 drives we get a total of 128 possible sets, with 4 drives we get a total of 256 possible sets. So algorithm automatically chooses 64 sets, which is *16* 64 = 1024* drives in total.

package http

import (
	"context"
	"net"
	"time"
)

// CheckPortAvailability - check if given host and port is already in use.
// Note: The check method tries to listen on given port and closes it.
// It is possible to have a disconnected client in this tiny window of time.
func CheckPortAvailability(host, port string, opts TCPOptions) (err error) {
	lc := &net.ListenConfig{}

 * <p>
 * This can potentially happen when a reference to the subject is retained during a rule and then used afterwards,
 * Such as when an anonymous inner class or closure “closes over” the subject.
 */
@Incubating
public class ModelViewClosedException extends ReadOnlyModelViewException {
    public ModelViewClosedException(ModelPath path, ModelType<?> type, ModelRuleDescriptor ruleDescriptor) {

import org.gradle.internal.resource.ExternalResourceName
import org.gradle.internal.resource.ReadableContent

class HttpResourceUploaderTest extends AbstractHttpClientTest {

    def 'uploader closes the request'() {
        given:
        HttpClientHelper client = Mock()
        ReadableContent resource = Mock()
        MockedHttpResponse mockedHttpResponse = mockedHttpResponse()

     */
    boolean getUnlockedCleanly();

    /**
     * Returns true if the given file is used by this lock.
     */
    boolean isLockFile(File file);

    /**
     * Closes this lock, releasing the lock and any resources associated with it.
     */
    @Override
    void close();

    /**
     * Returns some memento of the current state of this target file.
     */

        file.text == "bar⌘"
    }

    def "closes resource after executing action"() {
        def action = Mock(Action)
        def resource = Mock(Closeable)

        when:
        withResource(resource, action)

        then:
        1 * action.execute(resource)

        then:
        1 * resource.close()
        0 * _._
    }

    def "closes resource after action fails"() {