);
    }

    private static Stream<? extends ConfigurationDetails> getConfigurationsWhichCouldHaveDependencyInfo(Project project) {
        return project.getConfigurations().stream()
            .map(ConfigurationInternal.class::cast)
            .filter(c -> c.isDeclarableByExtension())
            .map(ConfigurationDetails::of);
    }

            });
        });
    }

    private void addTestResultsVariant(ProjectInternal project, JvmTestSuite suite, JvmTestSuiteTarget target) {
        final Configuration variant = project.getConfigurations().consumable(TEST_RESULTS_ELEMENTS_VARIANT_PREFIX + StringUtils.capitalize(target.getName())).get();

    }

    protected void beforeApply() {
    }

    @SuppressWarnings("deprecation")
    protected void createConfigurations() {
        Configuration configuration = project.getConfigurations().resolvableDependencyScopeUnlocked(getConfigurationName());
        configuration.setVisible(false);
        configuration.setTransitive(true);

                );
            }

            private Configuration detachedRuntimeClasspath(Dependency... dependencies) {
                Configuration classpath = project.getConfigurations().detachedConfiguration(dependencies);
                getJvmPluginServices().configureAsRuntimeClasspath(classpath);
                return classpath;
            }

 *
 * <p>You can obtain a {@code ConfigurationContainer} instance by calling {@link org.gradle.api.Project#getConfigurations()},
 * or using the {@code configurations} property in your build script.</p>
 *
 * <p>The configurations in a container are accessible as read-only properties of the container, using the name of the

        configuration("d", ["b", "c"])

        when:
        def md = metadata

        then:
        md.getConfiguration("a").hierarchy as List == ["a"]
        md.getConfiguration("b").hierarchy as List  == ["b", "a"]
        md.getConfiguration("c").hierarchy as List  == ["c", "a"]
        md.getConfiguration("d").hierarchy as List == ["d", "b", "a", "c"]
    }

    def "builds and caches artifacts for a configuration"() {

        when:
        def compileArtifacts = metadata.getConfiguration("compile").artifacts
        def runtimeArtifacts = metadata.getConfiguration("runtime").artifacts
        def defaultArtifacts = metadata.getConfiguration("default").artifacts

        then:
        runtimeArtifacts.size() == compileArtifacts.size()
        defaultArtifacts.size() == runtimeArtifacts.size()
    }

    def "recognises pom packaging"() {
        when:

        meta.addArtifact(a2, newHashSet("testUtil"))

        then:
        def resolveMetaData = meta.build().asImmutable()
        def runtimeArtifacts = resolveMetaData.getConfiguration("runtime").artifacts
        def testArtifacts = resolveMetaData.getConfiguration("testUtil").artifacts

        runtimeArtifacts*.id.displayName as Set == ["foo-1.0.jar (org:foo:1.0)"] as Set

                pomConfiguration = pluginExecution.getDelegate().getConfiguration();
            } else if (allowPluginLevelConfig) {
                pomConfiguration = plugin.getDelegate().getConfiguration();
            }

            XmlNode mojoConfiguration = mojoExecution.getConfiguration() != null
                    ? mojoExecution.getConfiguration().getDom()
                    : null;

        def variant = root.rootComponent.getConfiguration('conf')

        when:
        builder.validator.validateMutation(mutationType)
        def otherRoot = builder.toRootComponent('root')

        then:
        root.rootComponent.is(otherRoot.rootComponent)
        root.rootComponent.metadata.is(otherRoot.rootComponent.metadata)
        !otherRoot.rootComponent.getConfiguration('conf').is(variant)

        when: