/**
     * Get the resolvable configuration containing the resolved runtime dependencies
     * for this feature. This configuration does not contain the artifacts from the
     * feature's compilation itself.
     *
     * @return The {@code runtimeClasspath} configuration.
     */
    Configuration getRuntimeClasspathConfiguration();

    /**

        given:
        mavenRepo.module("org", "foo").publish()
        buildFile << """
            configurations {
                dependencyScope("deps")
                resolvable("res")  {
                    extendsFrom(deps)
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "foo"))
                    }
                }

should\ call\ method\ RoleBasedConfigurationContainerInternal.maybeCreateMigratingUnlocked(String,\ ConfigurationRole)\ or\ should\ call\ method\ RoleBasedConfigurationContainerInternal.maybeCreateResolvableDependencyScopeUnlocked(String),\ because\ Resolvable\ +\ dependency\ scope\ configurations\ should\ be\ avoided\ and\ we\ are\ migrating\ away\ from\ maybeCreate\ methods=configuration-factory-methods.txt...

                // need these resolution rules.
                id("org.jetbrains.kotlin.jvm") version "1.9.20"
            }

            configurations {
                dependencyScope("deps")
                resolvable("res") {
                    extendsFrom(deps)
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.LIBRARY))

        ResolutionNode resolvedNode = getConflictResolver().resolveConflict(actualNode1, actualNode2);

        assertNotNull(resolvedNode, "Expected resolvable");
        assertEquals(expectedNode, resolvedNode, "Resolution node");
    }

    protected Artifact createArtifact(String id, String version) throws InvalidVersionSpecificationException {

    }

    def "mainSourceElements can be consumed by another task via Dependency Management"() {
        buildFile << """
            plugins {
                id 'java'
            }

            // A resolvable configuration to collect source data
            def sourceElementsConfig = configurations.create("sourceElements") {
                visible = true
                assert canBeResolved
                canBeConsumed = false

                        config.getDependencies().add(project.getDependencies().create(project));
                    });

                    NamedDomainObjectProvider<Configuration> resolvable = configurations.register("resolvable", config -> {
                        config.setCanBeConsumed(false);
                        config.setCanBeResolved(true);
                        config.extendsFrom(dependencyScope.get());

By default, `resolvableConfigurations` prints information about all purely resolvable configurations.
These are configurations that are marked resolvable but *not* marked consumable.
Though some resolvable configurations are also marked consumable, these are legacy configurations that should *not* have dependencies added in build scripts.

            task jar3(type: Jar) {}

            configurations {
                consumable("con") {
                    outgoing.artifact(tasks.jar1)
                }
                resolvable("res") {
                    outgoing.artifact(tasks.jar2)
                }
                dependencyScope("dep") {
                    outgoing.artifact(tasks.jar3)
                }
            }

                role
        );
        instance.addMutationValidator(rootComponentMetadataBuilder.getValidator());
        return instance;
    }

    /**
     * Creates a new locked resolvable configuration instance.
     */
    DefaultResolvableConfiguration createResolvable(
        String name,
        ConfigurationsProvider configurationsProvider,