contextualLabel == 'Creating a configuration with a name that starts with \'detachedConfiguration\' has been deprecated.'
            solutions == ["Use a different name for the configuration '$name'.".toString()]
        }

        where:
        name << ["detachedConfiguration", "detachedConfiguration1", "detachedConfiguration22902"]
    }

        compile.description == "I compile!"
        compile.incoming.path == ":compile"
    }

    def "creates detached"() {
        given:
        1 * domainObjectContext.projectPath("detachedConfiguration1") >> Path.path(":detachedConfiguration1")
        1 * domainObjectContext.model >> RootScriptDomainObjectContext.INSTANCE

        def dependency1 = new DefaultExternalModuleDependency("group", "name", "version")

        'deprecation:plugin' : 'Plugin has been deprecated.',
        'deprecation:plugin-script' : 'Plugin script has been deprecated.',
        'deprecation:the-detachedconfiguration-configuration-has-been-deprecated-for-consumption' : 'The detachedConfiguration1 configuration has been deprecated for consumption.',

The ability to change the allowed usage of a configuration after creation will be removed in Gradle 9.0.

[[reserved_configuration_names]]
==== Reserved configuration names

Configuration names "detachedConfiguration" and "detachedConfigurationX" (where X is any integer) are reserved for internal use when creating detached configurations.

The ability to create non-detached configurations with these names will be removed in Gradle 9.0.

            def detached = project.configurations.detachedConfiguration()

            detached.canBeResolved = false
            detached.canBeConsumed = false
            detached.canBeDeclared = false
        """

        expect:
        expectConsumableChanging(":detachedConfiguration1", false)
        expectResolvableChanging(":detachedConfiguration1", false)

        return detachedConfiguration;
    }

    private String nextDetachedConfigurationName() {
        return DETACHED_CONFIGURATION_DEFAULT_NAME + detachedConfigurationDefaultNameCounter.getAndIncrement();
    }

    private void copyAllTo(DefaultConfiguration detachedConfiguration, Dependency[] dependencies) {

    companion object {
        fun of(container: ConfigurationContainer) =
            ConfigurationContainerScope(container)
    }

    override fun detachedConfiguration(vararg dependencies: Dependency): Configuration =
        delegate.detachedConfiguration(*dependencies)

    override fun resolvable(name: String): NamedDomainObjectProvider<ResolvableConfiguration> =
        delegate.resolvable(name)

@Measurement(iterations = 5)
@State(Scope.Benchmark)
public class DeprecationIdCreationBenchmark {

    @Benchmark
    public void idCreation(Blackhole bh) {
        bh.consume(createDefaultDeprecationId("The detachedConfiguration1 configuration has been deprecated for consumption."));
    }

            </thead>
            <tr>
                <td>getByName</td>
            </tr>
            <tr>
                <td>getAt</td>
            </tr>
            <tr>
                <td>detachedConfiguration</td>
            </tr>
            <tr>
                <td>consumable</td>
            </tr>
            <tr>
                <td>resolvable</td>
            </tr>
            <tr>

    doLast {
        println(classpath.files)
    }
}

// tag::disabling-detached-configuration[]
tasks.register("checkDetachedDependencies") {
    def detachedConf = configurations.detachedConfiguration(dependencies.create("org.apache.commons:commons-lang3:3.3.1"))
    detachedConf.resolutionStrategy.disableDependencyVerification()
    doLast {
        println(detachedConf.files)
    }
}