if (metadataType == "ivy") {
            // no variants are derived for plain ivy, but we can use a ivy configuration
            baseVariant = immutableMetadata.getConfiguration('runtime')
        }

        then:
        variants.size() == initialVariantCount + 1
        variants.last().name == 'new-variant'
        variants.last().attributes == baseVariant.attributes

        public Set<String> getConfigurationNames() {
            return delegate.getConfigurationNames();
        }

        @Override
        @Nullable
        public ModuleConfigurationMetadata getConfiguration(String name) {
            return new ClientModuleConfigurationMetadata(delegate.getId(), name, clientModuleArtifact, clientModuleDependencies);
        }

        @Override

        return new LenientPlatformResolveMetadata(moduleComponentIdentifier, moduleVersionIdentifier, platformState, platformNode, resolveState);
    }

    @Nullable
    @Override
    public ModuleConfigurationMetadata getConfiguration(String name) {
        if ("default".equals(name)) {
            ImmutableList.Builder<ModuleDependencyMetadata> dependencies = new ImmutableList.Builder<>();

        } catch (Exception e) {
            throw new PluginContainerException(mojoDescriptor, pluginRealm, "Unable to lookup Mojo", e);
        }

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

        PlexusConfiguration pomConfiguration;

        if (dom == null) {

                        .priority(i - mojos.size())
                        .phase(phase)
                        .goals(List.of(goal))
                        .configuration(mojo.getConfiguration())
                        .location("", location)
                        .location("id", location)
                        .location("phase", location)
                        .location("goals", location)

    }

    @Override
    public Set<String> getConfigurationNames() {
        return configurations.keySet();
    }

    @Nullable
    @Override
    public ModuleConfigurationMetadata getConfiguration(String name) {
        return configurations.get(name);
    }

    @Override
    public List<? extends VariantGraphResolveMetadata> getVariantsForGraphTraversal() {
        if (graphVariants == null) {

        LocalComponentGraphResolveState state = getComponentState(module, componentIdentifier);
        ConfigurationGraphResolveState configuration = state.getConfiguration(configurationName);
        if (configuration == null) {
            throw new IllegalArgumentException(String.format("Expected configuration '%s' to be present in %s", configurationName, componentIdentifier));
        }

        WrapperExecutor wrapper = WrapperExecutor.forProjectDirectory(layout.getRootDirectory());
        if (wrapper.getDistribution() != null) {
            return new ZippedDistribution(wrapper.getConfiguration(), clock);
        }
        return getDownloadedDistribution(GradleVersion.current().getVersion());
    }

    /**
     * Returns the distribution installed in the specified directory.
     */

            authBuilder.addPrivateKey(server.getPrivateKey(), server.getPassphrase());
            authSelector.add(server.getId(), authBuilder.build());

            if (server.getConfiguration() != null) {
                XmlNode dom = server.getDelegate().getConfiguration();
                List<XmlNode> children = dom.getChildren().stream()
                        .filter(c -> !"wagonProvider".equals(c.getName()))

                realm,
                Collections.singleton(artifacts.get(0).getFile()),
                extension.getGroupId() + ":" + extension.getArtifactId(),
                extension.getConfiguration());
    }

    private List<Artifact> resolveExtension(
            CoreExtension extension,
            RepositorySystemSession repoSession,
            List<RemoteRepository> repositories,