*
     * @deprecated A value of {@code true} does not mean that the dependency should
     * be placed on the classpath. See {@code JavaPathType} instead for better analysis.
     */
    @Deprecated
    boolean isAddedToClasspath();

    def setup() {
        // Generate Kotlin DSL sources once so they are included as :kotlin-dsl:compileKotlin inputs.
        // TODO:configuration-cache handle generated sources better (see gradlebuild.kotlin-dsl-dependencies-embedded.gradle.kts:39)
        run([':kotlin-dsl:generateKotlinDependencyExtensions'])
    }

    TestExecutionResult assertTestClassExecutedIn(String subProjectDir, String testClass) {

    protected void defaultSpec(GradleBuildExperimentSpec.GradleBuilder builder) {
    }

    protected void finalizeSpec(GradleBuildExperimentSpec.GradleBuilder builder) {
    }

    static {
        // TODO - find a better way to cleanup
        System.addShutdownHook {
            ((Closeable) RESULTS_STORE).close()
        }
    }

                    result.getMissingArtifacts(),
                    request.getRemoteRepositories());
        }

        // this should never happen since we checked all possible error sources before but better be sure
        if (result.hasExceptions()) {
            throw new ArtifactResolutionException(
                    "Unknown error during artifact resolution, " + request + ", " + result.getExceptions(),

    @Test
    @ToBeFixedForConfigurationCache
    void triggersBeforeAndWhenConfigurationHooks() {

        //this test is a bit peculiar as it has assertions inside the gradle script
        //couldn't find a better way of asserting on before/when configured hooks
        runIdeaTask '''
apply plugin: 'java'
apply plugin: 'idea'

def beforeConfiguredObjects = 0
def whenConfiguredObjects = 0

idea {
    project {

        // When there may be no more than one configuration, don't cache the resolution state for reuse. Currently, this only applies to detached configurations, however
        // it might be better to skip caching when it's likely there is only one configuration defined, for example, for script class paths, as the meta-data is unlikely to be reused.

            }
        }

        buildFile << """
            configurations.conf.resolutionStrategy.dependencySubstitution {
                substitute module("org:old") because "better foo than old" using module("org:foo:2.0")
            }
            dependencies {
                conf('org:foo') {
                   version { strictly '1.0' }
                }

     *
     * This is only well supported for PMD 5.2.1 or better.
     *
     * @since 2.8
     */
    public void setClasspath(@Nullable FileCollection classpath) {
        this.classpath = classpath;
    }

    /**
     * Controls whether to use incremental analysis or not.
     *

	if !features.MultiRootMesh {
		return false
	}

	if req == nil {
		return true
	}

	if !req.Full {
		return false
	}

	if len(req.ConfigsUpdated) == 0 {
		// This needs to be better optimized
		return true
	}

	return false
}

// Generate returns ProxyConfig protobuf containing TrustBundle for given proxy

// in a separate Goroutine and then serves the long running request in the main Goroutine. Doing so allows
// freeing stack memory used in preparation Goroutine for better memory efficiency.
func WithRoutine(handler http.Handler, longRunning request.LongRunningRequestCheck) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		ctx := req.Context()