// no plugin application, must create configurations manually
                    DependencyScopeConfiguration api = project.getConfigurations().dependencyScope("api").get();
                    DependencyScopeConfiguration implementation = project.getConfigurations().dependencyScope("implementation").get();

                    // create and wire the custom dependencies extension's dependencies to these global configurations

        }
        ImmutableList.Builder<ExcludeMetadata> rules = ImmutableList.builderWithExpectedSize(excludes.size());
        for (Exclude exclude : excludes) {
            Set<String> ruleConfigurations = exclude.getConfigurations();
            if (include(ruleConfigurations, configurations)) {
                rules.add(exclude);
            }
        }
        return rules.build();
    }

                        });
                    }

                    private Configuration createBaseConfiguration(Project project) {
                        return project.getConfigurations().create("$TRANSFORM_SOURCE_CONFIGURATION", cfg -> {
                            cfg.setCanBeConsumed(false);
                            cfg.setCanBeResolved(true);
                        });
                    }

                        suppliers.add(supplier);
                    }

                    public void addSupplierWithConfiguration() {
                        Configuration c = getProject().getConfigurations().create("test");
                        addSupplier(() -> "configuration name is " + c.getName());
                    }

                    public void addSupplierWithSourceDirectorySet() {

        delegate.status

    override fun mkdir(path: Any): File =
        delegate.mkdir(path)

    override fun setStatus(status: Any) {
        delegate.status = status
    }

    override fun getConfigurations(): ConfigurationContainer =
        delegate.configurations

    override fun getArtifacts(): ArtifactHandler =
        delegate.artifacts

    override fun setDescription(description: String?) {

        return () -> {
            SourceSet sourceSet = extension.getPluginSourceSet();
            Configuration runtimeClasspath = project.getConfigurations().getByName(sourceSet.getRuntimeClasspathConfigurationName());
            ArtifactView view = runtimeClasspath.getIncoming().artifactView(config ->

    public void setConfiguration(@Nullable String configurationName) {
        setConfiguration(
            configurationName == null
                ? null
                : ConfigurationFinder.find(getProject().getConfigurations(), configurationName)
        );
    }

    /**
     * Tells if the report should only show one path to each dependency.
     *
     * @since 4.9
     */
    @Internal

            public class WorkerRunningPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    ConfigurationContainer configurations = project.getConfigurations();
                    NamedDomainObjectProvider<DependencyScopeConfiguration> dependencyScope = configurations.dependencyScope("deps", config -> {

        }

        override fun ant(configureAction: Action<in AntBuilder>): AntBuilder {
            onAccess("ant")
            return delegate.ant(configureAction)
        }

        override fun getConfigurations(): RoleBasedConfigurationContainerInternal {
            onAccess("configurations")
            return delegate.configurations
        }

        override fun configurations(configureClosure: Closure<*>) {

We provide the outputs of the `jar` task as well as the JAR of all the dependencies (using link:{javadocPath}/org/gradle/api/Project.html#getConfigurations--[`configurations`]link:{javadocPath}/org/gradle/api/tasks/SourceSet.html#getRuntimeClasspath--[`.runtimeClasspath`]) as additional inputs.

For outputs, we need to define two properties.