TaskProvider<GroovyCompile> compileTask = createGroovyCompileTask(project, sourceSet, groovySource);

            ConfigurationContainer configurations = project.getConfigurations();
            configureLibraryElements(sourceSet, configurations, project.getObjects());
            configureTargetPlatform(compileTask, sourceSet, configurations);
        });
    }

    /**

        runtime.add(mainFeature.getRuntimeClasspathConfiguration());

        ConfigurationContainer configurations = project.getConfigurations();
        Collection<Configuration> test = scopes.get(GeneratedIdeaScope.TEST.name()).get(IdeaDependenciesProvider.SCOPE_PLUS);

                        suppliers.add(supplier);
                    }

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

                    public void addSupplierWithSourceDirectorySet() {

        final List<ReportAttribute> attributesWithDisambiguationRules = scanner.getAttributesWithDisambiguationRules();

        ConfigurationContainerInternal configurations = (ConfigurationContainerInternal) project.getConfigurations();
        final Map<String, ReportConfiguration> convertedConfigurations = new HashMap<>(configurations.size());

        model.description = descriptor.getDescription();

        model.authors.addAll(descriptor.getAuthors());
        model.licenses.addAll(descriptor.getLicenses());
        model.configurations.addAll(descriptor.getConfigurations().get());

        Set<IvyExcludeRule> globalExcludes = descriptor.getGlobalExcludes().getOrNull();
        if (globalExcludes != null) {
            model.globalExcludes.addAll(globalExcludes);
        }

        String docsType,
        Set<Capability> capabilities,
        String jarTaskName,
        Object artifactSource,
        ProjectInternal project
    ) {
        Configuration variant = project.getConfigurations().maybeCreateMigratingUnlocked(variantName, ConfigurationRolesForMigration.CONSUMABLE_DEPENDENCY_SCOPE_TO_CONSUMABLE);
        variant.setVisible(false);

            for (Artifact artifact : artifacts) {
                IvyArtifactNameSerializer.INSTANCE.write(encoder, artifact.getArtifactName());
                writeStringSet(artifact.getConfigurations());
            }
        }

        private void writeIvyDependencies(List<IvyDependencyDescriptor> dependencies) throws IOException {
            writeCount(dependencies.size());

    /**
     * Returns the complete set of configurations for this publication.
     * @return the configurations
     */
    IvyConfigurationContainer getConfigurations();

    /**
     * Creates a custom {@link IvyArtifact} to be included in the publication.
     *
     * The <code>artifact</code> method can take a variety of input:
     * <ul>

        maybeEmitMissingJavaComponentDeprecation("consistentResolution(Action)");

        final SoftwareComponentContainer components = project.getComponents();
        final ConfigurationContainer configurations = project.getConfigurations();
        final SourceSetContainer sourceSets = getSourceSets();
        action.execute(project.getObjects().newInstance(DefaultJavaPluginExtension.DefaultJavaResolutionConsistency.class, components, sourceSets, configurations));

            on { plugins } doReturn mapOf("customConvention" to customConvention)
        }
        val project = mock<ProjectInternal> {
            on { getConfigurations() } doReturn configurations
            on { getExtensions() } doReturn extensions
            on { getDependencies() } doReturn dependencies
            on { getTasks() } doReturn tasks