* the compile classpath and the runtime classpath, the version from the
     * compile classpath is going to be used.
     *
     * Unless you have a good reason to, this option should be preferred to
     * {@link #useRuntimeClasspathVersions()} for different reasons:
     *
     * <ul>
     *     <li>As code is compiled first against the given dependencies,
     *     it is expected that the versions at runtime would be the same.

import java.util.ArrayList;
import java.util.List;

/**
 * Provides metadata about a build extension. <strong>Warning:</strong> This is an internal utility class that is only
 * public for technical reasons, it is not part of the public API. In particular, this class can be changed or deleted
 * without prior notice.
 *
 */
public class ExtensionDescriptor {

    private List<String> exportedPackages;

 * That also means that Gradle does not do any optimizations for running the task.
 * For example, such a task will always be out of date and never stored in or loaded from the build cache.
 *
 * <p>There can be different reasons for declaring a task as untracked, for example:
 * <ul>
 *     <li>Some input or output locations contain unreadable files like pipes where Gradle cannot track the content.</li>

    @Override
    public void discardAll() {
        outputHierarchy.clear();
        destroyableHierarchy.clear();
    }

    /**
     * Create the input node access hierarchy.
     *
     * For performance reasons, we keep one input node access hierarchy per project,
     * so we only have a factory method here and this is used to create the hierarchy in {@link org.gradle.execution.ProjectExecutionServices}.
     */

     * may not include all the variants returned by {@link #getVariants()}.
     *
     * <p>
     * Note: for performance reasons,
     * {@link org.gradle.api.internal.artifacts.configurations.ResolutionStrategyInternal#setIncludeAllSelectableVariantResults(boolean)}
     * must be set to {@code true} for this to actually return all variants in all cases.

        captureResults[1].assertTaskExecuted(':capture2')

        cleanup:
        daemon?.abort()
    }

    def "a daemon expiration listener receives expiration reasons continuous:#continuous"() {
        given:
        buildFile << """
           ${imports()}
           ${registerTestExpirationStrategy()}
           ${registerExpirationListener()}
           ${waitForExpirationTask()}

special syntax (described below). The test driver is implemented as
an action within the GOROOT/test test suite, called "asmcheck".

The codegen harness is part of the all.bash test suite, but for
performance reasons only the codegen tests for the host machine's
GOARCH are enabled by default, and only on GOOS=linux.

To perform comprehensive tests for all the supported architectures

	// DNSDone is called after a DNS lookup completes (or fails).
	// The coalesced parameter is whether singleflight de-duped
	// the call. The addrs are of type net.IPAddr but can't
	// actually be for circular dependency reasons.
	DNSDone func(netIPs []any, coalesced bool, err error)

	// ConnectStart is called before a Dial, excluding Dials made
	// during DNS lookups. In the case of DualStack (Happy Eyeballs)

			want: false,
		},
		{
			name: "one status should be equal to itself",
			x:    errorStatus,
			y:    errorStatus,
			want: true,
		},
		{
			name: "same type statuses without reasons should be equal",
			x:    NewStatus(Success),
			y:    NewStatus(Success),
			want: true,
		},
		{
			name: "statuses with same message should be equal",
			x:    NewStatus(Unschedulable, "unschedulable"),

     *
     * <b>IMPLEMENTATION NOTE</b>
     * We do it this way instead of the way recommended in <a href="https://snyk.io/research/zip-slip-vulnerability"></a>
     * for performance reasons, calling {@link File#getCanonicalPath()} is too expensive.
     *
     * @throws IllegalArgumentException if the entry contains vulnerable sequences
     */
    public static String safePathName(String name) {