}

    @Override
    public Configuration dependencyScopeUnlocked(String name) {
        assertMutable("dependencyScopeUnlocked(String)");
        return createUnlockedConfiguration(name, ConfigurationRoles.DEPENDENCY_SCOPE, Actions.doNothing());
    }

    @Override
    public Configuration dependencyScopeUnlocked(String name, Action<? super Configuration> action) {

        super(configurations, implementationName);
        apiDependencies = configurations.dependencyScopeUnlocked(apiName);
        getImplementationDependencies().extendsFrom(apiDependencies);
    }

    public Configuration getApiDependencies() {
        return apiDependencies;
    }

    @Override

            dependencyScope("b", {})
        }
        verifyUnlocked(ConfigurationRoles.DEPENDENCY_SCOPE, "c") {
            dependencyScopeUnlocked("c")
        }
        verifyUnlocked(ConfigurationRoles.DEPENDENCY_SCOPE, "d") {
            dependencyScopeUnlocked("d", {})
        }
        verifyUnlocked(ConfigurationRoles.DEPENDENCY_SCOPE, "e") {
            maybeCreateDependencyScopeUnlocked("e")
        }

    def dependencyFactory = Mock(DependencyHandler)
    def apiDeps = Mock(Configuration)
    def deps = Mock(DependencySet)
    DefaultLibraryDependencies dependencies

    def setup() {
        configurations.dependencyScopeUnlocked("api") >> apiDeps
        apiDeps.dependencies >> deps

        dependencies = new DefaultLibraryDependencies(configurations, "impl", "api") {
            @Override

        Capability enforcedCapability = new ShadowedImmutableCapability(new ProjectDerivedCapability(project), "-derived-enforced-platform");

        Configuration api = configurations.dependencyScopeUnlocked(API_CONFIGURATION_NAME);
        Configuration apiElements = createConsumableApi(project, api, API_ELEMENTS_CONFIGURATION_NAME, Category.REGULAR_PLATFORM);

    @Inject
    public DefaultComponentDependencies(RoleBasedConfigurationContainerInternal configurations, String implementationName) {
        implementation = configurations.dependencyScopeUnlocked(implementationName);
    }

    public Configuration getImplementationDependencies() {
        return implementation;
    }

    @Inject
    protected DependencyHandler getDependencyHandler() {

    def dependencyFactory = Mock(DependencyHandler)
    def implDeps = Mock(Configuration)
    def deps = Mock(DependencySet)
    DefaultComponentDependencies dependencies

    def setup() {
        configurations.dependencyScopeUnlocked("impl") >> implDeps
        implDeps.dependencies >> deps

        dependencies = new DefaultComponentDependencies(configurations, "impl") {
            @Override

     * Creates a dependency scope configuration which can change roles.
     */
    Configuration dependencyScopeUnlocked(String name);

    /**
     * Creates a dependency scope configuration which can change role and executes the provided
     * {@code action} against the configuration.
     */
    Configuration dependencyScopeUnlocked(String name, Action<? super Configuration> action);

    /**

    }

    private Configuration createDependenciesConfiguration(ProjectInternal project) {
        return project.getConfigurations().dependencyScopeUnlocked(GRADLE_PLATFORM_DEPENDENCIES, cnf -> {
            cnf.setVisible(false);
        });
    }

    private TaskProvider<TomlFileGenerator> createGenerator(Project project, CatalogExtensionInternal extension) {

        }
    }

    @Override
    protected void createConfigurations() {
        super.createConfigurations();
        Configuration auxClasspath = project.getConfigurations().dependencyScopeUnlocked(PMD_ADDITIONAL_AUX_DEPS_CONFIGURATION, additionalAuxDepsConfiguration -> {
            additionalAuxDepsConfiguration.setDescription("The additional libraries that are available for type resolution during analysis");