*
 * <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:

            XmlNode pluginConfiguration = plugin.getConfiguration();
            if (pluginConfiguration != null) {
                return plugin.withExecutions(map(
                        plugin.getExecutions(),
                        execution -> execution.withConfiguration(
                                XmlNode.merge(execution.getConfiguration(), pluginConfiguration))));
            } else {
                return plugin;

                XmlNode parentDom = reportPlugin.getDelegate().getConfiguration();

                if (parentDom != null) {
                    for (ReportSet execution : reportPlugin.getReportSets()) {
                        XmlNode childDom = execution.getDelegate().getConfiguration();
                        childDom = XmlNode.merge(childDom, parentDom);

                    if (pluginExecutionId.equals(execution.getId())) {
                        setConfiguration(execution.getConfiguration());
                        break;
                    }
                }
            } else {
                setConfiguration(plugin.getConfiguration());
            }
        }
        return this;
    }

    } // -- void addGoal( String )

    /**
     * Get configuration to pass to the goals.
     *
     * @return Object
     */
    public Object getConfiguration() {
        return this.configuration;
    } // -- Object getConfiguration()

    /**
     * Method getGoals.
     *
     * @return List
     */
    public java.util.List<String> getGoals() {
        if (this.goals == null) {