extension.getCssFiles().from(css);

        extension.getRenderedDocumentation().from(stageDocs);

        Configuration runtimeClasspath = project.getConfigurations().getByName("runtimeClasspath");
        Configuration sourcesPath = project.getConfigurations().create("sourcesPath");
        sourcesPath.attributes(a -> {
            a.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, Usage.JAVA_RUNTIME));

     *
     * @return The set of configurations that apply, or an empty set if this exclude applies to _all_ configurations.
     */
    Set<String> getConfigurations();

        AttributesSchemaInternal schema = (AttributesSchemaInternal) project.getDependencies().getAttributesSchema();
        ConfigurationsProvider configurations = (DefaultConfigurationContainer) project.getConfigurations();

        return resolveStateFactory.stateFor(projectState, componentIdentifier, moduleVersionIdentifier, configurations, module.getStatus(), schema);
    }

            task.dependsOn((Callable<FileCollection>) () -> mainFeature.getSourceSet().getRuntimeClasspath());
            task.classpath((Callable<FileCollection>) () -> {
                Configuration providedRuntime = project.getConfigurations().getByName(PROVIDED_RUNTIME_CONFIGURATION_NAME);
                return mainFeature.getSourceSet().getRuntimeClasspath().minus(providedRuntime);
            });
        });

        Attribute<Boolean> javaModule = Attribute.of("javaModule", Boolean.class);

        // compile and runtime classpath express that they only accept modules by requesting the javaModule=true attribute
        project.getConfigurations().matching(this::isResolvingJavaPluginConfiguration).all(
                c -> c.getAttributes().attribute(javaModule, true));

     */
    @Override
    RoleBasedConfigurationContainerInternal getConfigurations();

    interface DetachedResolver {
        RepositoryHandler getRepositories();

        DependencyHandler getDependencies();

        ConfigurationContainer getConfigurations();
    }

            this.file = file
            this.rawUuid = rawUuid
        }

        String getUuid() {
            return '{' + rawUuid + '}'
        }

        Map<String, String> getConfigurations() {
            def configurations = [:]
            content.eachMatch(~/\{${rawUuid}\}\.([\w\\-]+)\|\w+\.ActiveCfg = ([\w\\-]+)\|\w+/, {
                configurations[it[1]] = it[2]
            })

        }
        getExtensions() >> Stub(ExtensionContainerInternal) {
            getByType(JavaPluginExtension) >> Mock(JavaPluginExtension)
        }
        getTasks() >> tasks
        getConfigurations() >> configurations
    }

    @Subject
    DefaultJvmPluginServices services = new DefaultJvmPluginServices(
        TestUtil.objectFactory(),
        TestUtil.providerFactory(),

    override fun getDependencies(): DependencyHandler =
        delegate.dependencies

    override fun dependencies(configureClosure: Closure<Any>) =
        delegate.dependencies(configureClosure)

    override fun getConfigurations(): ConfigurationContainer =
        delegate.configurations

    override fun configurations(configureClosure: Action<in ConfigurationContainer>) =
        delegate.configurations(configureClosure)

        JvmFeatureInternal mainFeature = JavaPluginHelper.getJavaComponent(project).getMainFeature();

        configureScaladoc(project, mainFeature);

        final Configuration incrementalAnalysisElements = project.getConfigurations().getByName("incrementalScalaAnalysisElements");
        String compileTaskName = mainFeature.getSourceSet().getCompileTaskName("scala");