if len(add) != 0 {
		// add should be empty in workspace mode because workspace mode implies
		// -mod=readonly, which in turn implies no new requirements. The code path
		// that would result in add being non-empty returns an error before it
		// reaches this point: The set of modules to add comes from

type reader struct {
	mode Mode

	// package properties
	doc       string // package documentation, if any
	filenames []string
	notes     map[string][]*Note

	// imports
	imports      map[string]int
	hasDotImp    bool // if set, package contains a dot import
	importByName map[string]string

	// declarations
	values []*Value // consts and vars

        where:
        version << SUPPORTED_WITH_GRADLE_8_CONFIGURATION_CACHE
    }

    @Requires(value = IntegTestPreconditions.NotConfigCached, reason = "Isolated projects implies config cache")
    def "can use plugin #version with isolated projects"() {
        given:
        def versionNumber = VersionNumber.parse(version)

        when:
        usePluginVersion version

        return new TransformFixture(
            """
            import ${Inject.name};
            import ${ExecOperations.name};
            ${snippets.imports}
            """,

            """
            @Inject
            public abstract ExecOperations getExecOperations();
            """,

            snippets.body
        )
    }

import org.gradle.tooling.events.test.TestOutputEvent

@TargetGradleVersion('>=6.0')
class TestOutputCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {

    def "test execution exposes test output"() {
        when:
        runTestAndCollectProgressEvents()
        def events = getOutputEvents()

        then:

        } else {
            foreignImports.put("", classRealmManager.getMavenApiRealm());
        }

        if (parent != null && imports != null) {
            for (String parentImport : imports) {
                foreignImports.put(parentImport, parent);
            }
        }

        return foreignImports;
    }

    public <T> T getConfiguredMojo(Class<T> mojoInterface, MavenSession session, MojoExecution mojoExecution)

<a name="FILL-IN-KEY-AREA"></a>
### FILL-IN-KEY-AREA improvements

<<<FILL IN CONTEXT FOR KEY AREA>>>
Example:
> The [configuration cache](userguide/configuration_cache.html) improves build performance by caching the result of
> the configuration phase. Using the configuration cache, Gradle can skip the configuration phase entirely when
> nothing that affects the build configuration has changed.

        val trace = tracingCodeResolver(DefaultOperationGenerationId.finalEvaluation, analysisStatementFilter)
            .apply { resolve(analysisSchema, languageModel.imports, languageModel.topLevelBlock) }
            .trace
        val document = languageModel.toDocument()
        val resolution = resolutionContainer(analysisSchema, trace, document)

        val packages = packageHeader(tree, packageNode)
        val imports = importNodes.map { import(tree, it) }
        val statements = scriptNodes.map { statement(tree, it) }

        val headerFailures = collectFailures(packages + imports)

        return LanguageTreeResult(
            imports = imports.filterIsInstance<Element<Import>>().map { it.element },

     */
    void maybeDiscardStateRequiredForGraphResolution();

    /**
     * Sets whether or not any configuration resolution is final and the state required for resolution can be
     * discarded.  Setting this to true implies that the configuration may be re-resolved again in the future.
     *
     * Defaults to false.
     */
    void setKeepStateRequiredForGraphResolution(boolean keepStateRequiredForGraphResolution);

    /**