immutable.variants[1].dependencies.size() == 1

        def immutable2 = immutable.asMutable().asImmutable()
        immutable2.variants[0].dependencies.size() == 2
        immutable2.variants[1].dependencies.size() == 1

        def copy = immutable.asMutable()
        copy.variants.size() == 2
        copy.addVariant("link", attributes())
        copy.variants.size() == 3

                StringBuilder result = asMutable();
                result.setCharAt(0, Character.toUpperCase(result.charAt(0)));
                return result.toString();
            }

            @Override
            public String getDisplayName() {
                return asMutable().toString();
            }

            private StringBuilder asMutable() {
                String typeStr = type.toString();

        immutable.getConfiguration("master").artifacts.size() == 1
        !immutable.getConfiguration("unknown")

        and:
        def copy = immutable.asMutable()
        copy != metadata
        copy.id == id
        copy.sources == new MutableModuleSources()
        copy.statusScheme == ExternalComponentResolveMetadata.DEFAULT_STATUS_SCHEME

        }
        return modelView;
    }

    @Override
    public <T> ModelView<? extends T> asMutable(ModelType<T> type, ModelRuleDescriptor ruleDescriptor) {
        ModelView<? extends T> modelView;
        if (isMutable()) {
            modelView = getAdapter().asMutable(type, this, ruleDescriptor);
        } else {
            modelView = getAdapter().asImmutable(type, this, ruleDescriptor);
        }

                builder.add(getConfiguration(potentialVariantName));
            }
        }
        return builder.build();
    }

    @Override
    public MutableIvyModuleResolveMetadata asMutable() {
        return metadata.asMutable();
    }

    @Override
    public RealisedIvyModuleResolveMetadata withSources(ModuleSources sources) {

        given:
        action.getDescriptor() >> new SimpleModelRuleDescriptor("action")
        action.execute(_, _) >> { MutableModelNode node, ModelActionRole role ->
            def thing = node.asMutable(itemType, Stub(ModelRuleDescriptor)).instance
            thing.other = "changed"
        }

        when:
        mutateWithoutDelegation {
            it.a(itemClass, action)

                    updatedMetadata = processClassRuleWithCaching(ia, metadata, metadataResolutionContext);
                } else {
                    MutableModuleComponentResolveMetadata mutableMetadata = metadata.asMutable();
                    processClassRule(action, metadata, createDetails(mutableMetadata));
                    updatedMetadata = maybeForceRealisation(mutableMetadata.asImmutable());
                }
            } else {

            return false;
        }
        return hierarchy.contains(dependency.getScope().getLowerName());
    }

    @Override
    public MutableMavenModuleResolveMetadata asMutable() {
        return new DefaultMutableMavenModuleResolveMetadata(this, objectInstantiator);
    }

    @Override
    public DefaultMavenModuleResolveMetadata withSources(ModuleSources sources) {

            return this;
        }
        return new RealisedMavenModuleResolveMetadata(this, getSources(), derivationStrategy);
    }

    @Override
    public MutableMavenModuleResolveMetadata asMutable() {
        return new DefaultMutableMavenModuleResolveMetadata(this, objectInstantiator);
    }

    @Override
    public String getPackaging() {
        return packaging;
    }

    @Override

        }
        def metadata = mavenMetadataFactory.create(componentIdentifier, dependencies)
            .asImmutable()
            .withDerivationStrategy(JavaEcosystemVariantDerivationStrategy.instance)
            .asMutable()
        metadata
    }

    private gradleComponentMetadata(String[] deps) {
        def metadata = mavenMetadataFactory.create(componentIdentifier, [])