}

    void doesNotHaveLegacyLegend() {
        outputDoesNotContain("(l) Legacy or deprecated configuration. Those are variants created for backwards compatibility which are both resolvable and consumable.")
    }

    void hasIncubatingLegend() {

    }
}
"""

        when:
        executer.expectDocumentedDeprecationWarning("Directly resolving a file collection dependency's files has been deprecated. This will fail with an error in Gradle 9.0. Add the dependency to a resolvable configuration and resolve the configuration. Consult the upgrading guide for further information: https://docs.gradle.org/current/userguide/upgrading_version_8.html#deprecate_self_resolving_dependency")

    /**
     * Creates a resolvable + dependency scope configuration which can change roles.
     *
     * @deprecated Whether concept of a resolvable + dependency scope configuration should exist
     * is still under debate. However, in general, we should try to split up configurations which
     * have this role into separate resolvable and dependency scope configurations.
     */
    @Deprecated

    /**
     * Registers a {@link ResolvableConfiguration} with an immutable role. Resolvable configurations
     * are meant to resolve dependency graphs and their artifacts.
     *
     * @param name The name of the configuration to register.
     *
     * @return A provider which creates a new resolvable configuration.
     *

        componentIdentifierFactory.createComponentIdentifier(_) >> {
            new DefaultModuleComponentIdentifier(mid, '1.0')
        }
        configurationsProvider.findByName('conf') >> resolvable()
        configurationsProvider.findByName('conf-2') >> resolvable()

        def root = builder.toRootComponent('conf')

        when:
        def sameConf = builder.toRootComponent('conf')

        then:

    }

    @Override
    @Deprecated
    public Set<File> resolve() {
        DeprecationLogger.deprecate("Directly resolving a file collection dependency's files")
            .withAdvice("Add the dependency to a resolvable configuration and resolve the configuration.")
            .willBecomeAnErrorInGradle9()
            .withUpgradeGuideSection(8, "deprecate_self_resolving_dependency")
            .nagUser();

     * @implSpec Usage: This method should only be called on resolvable configurations and should throw an exception if
     * called on a configuration that does not permit this usage.
     */
    RootComponentMetadataBuilder.RootComponentState toRootComponent();

    AttributeContainerInternal getAttributes();

    /**
     * @implSpec Usage: This method should only be called on resolvable configurations and should throw an exception if

/**
 * Returns a [KaClassLikeSymbol] for this [KaType] if the type represents a uniquely resolvable class/object/type alias.
 */
public val KaType.symbol: KaClassLikeSymbol?
    get() = (this as? KaNonErrorClassType)?.symbol

/**
 * Returns a [KtClassLikeSymbol] for this [KtType] if the type represents a uniquely resolvable class/object/type alias.
 */
@Deprecated("Use 'symbol' instead.", ReplaceWith("this.symbol"))

     * superconfigurations.
     */
    Set<ExcludeRule> getAllExcludeRules();

    /**
     * @implSpec Usage: This method should only be called on resolvable configurations and should throw an exception if
     * called on a configuration that does not permit this usage.
     */
    @Nullable
    ConfigurationInternal getConsistentResolutionSource();

    /**

package cgotest

import "testing"

// If gcc is used, and linking internally, __mulsc3 and __muldc3
// will be linked in from libgcc which make several R_PPC64_TOC16_DS
// relocations which may not be resolvable with the internal linker.
func test8694(t *testing.T) { t.Skip("not supported on ppc64/ppc64le with internal linking") }