// at any time.
// Typically this means the calls to Add should execute before the statement
// creating the goroutine or other event to be waited for.
// If a WaitGroup is reused to wait for several independent sets of events,
// new Add calls must happen after all previous Wait calls have returned.
// See the WaitGroup example.
func (wg *WaitGroup) Add(delta int) {
	if race.Enabled {
		if delta < 0 {

import org.gradle.test.fixtures.file.LeaksFileHandles
import spock.lang.Issue

@LeaksFileHandles
class PluginUseClassLoadingIntegrationSpec extends AbstractPluginSpec {

    def "plugin classes are reused if possible"() {
        given:
        publishPlugin()
        settingsFile << """
            include "p1"
            include "p2"
        """

        when:
        file("p1/build.gradle") << USE

func IsHTTP2ConnectionLost(err error) bool {
	return err != nil && strings.Contains(err.Error(), "http2: client connection lost")
}

// Returns if the given err is "connection refused" error
func IsConnectionRefused(err error) bool {
	var errno syscall.Errno
	if errors.As(err, &errno) {
		return errno == syscall.ECONNREFUSED
	}
	return false

import javax.annotation.concurrent.ThreadSafe;

/**
 * A specialized {@link ComponentGraphResolveState} for external components.
 *
 * <p>Instances of this type are cached and reused for multiple graph resolutions, possibly in parallel. This means that the implementation must be thread-safe.
 */
@ThreadSafe
public interface ModuleComponentGraphResolveState extends ExternalComponentGraphResolveState {

        configurationCacheRun(task, *options)
        def secondRunOutput = removeVfsLogOutput(result.normalizedOutput)
            .replaceAll(/Reusing configuration cache.\n/, '')
            .replaceAll(/Configuration cache entry reused.\n/, '')

        then:
        firstRunOutput == secondRunOutput

        where:
        task                    | options
        "dependencyReport"      | []
        "taskReport"            | []

    public static final String SUBSEQUENT_BUILDS_WILL_BE_FASTER = "(subsequent builds will be faster)";
    public static final String NOT_REUSED_MESSAGE = " could not be reused, use --status for details";

    public static String generate(final int numBusy, final int numIncompatible, final int numStopped) {
        final int totalUnavailableDaemons = numBusy + numIncompatible + numStopped;

    /**
     * Whether the task was executed incrementally.
     */
    boolean executedIncrementally();

    /**
     * If the execution resulted in some previous output being reused, this returns its origin metadata.
     */
    Optional<OriginMetadata> getReusedOutputOriginMetadata();

    /**
     * The caching state of the task, including all its captured inputs and the cache key if calculated.

            }
            break;
        case ERR_SSN_SRVC:
            result += "ERR_SSN_SRVC/";
            switch ( errorCode ) {
            case CONNECTION_REFUSED:
                result += "Connection refused";
                break;
            case NOT_LISTENING_CALLED:
                result += "Not listening on called name";
                break;
            case NOT_LISTENING_CALLING:

	if err != nil {
		panic(err) // internal fault, not user
	}
	return nil
}

var (
	ErrNotExist = errors.New("name does not exist") // maps to RCode3, NXDOMAIN
	ErrRefused  = errors.New("refused")             // maps to RCode5, REFUSED
)

type resolverFuncConn struct {
	h       *resolverDialHandler
	network string
	address string
	builder *dnsmessage.Builder
	q       dnsmessage.Question
	ttl     uint32

Since HTTP requests frequently happen in parallel, connection pooling must be thread-safe.

These are the primary classes involved with establishing, sharing, and terminating connections: