}
    }

    private void writeStatusScheme(Encoder encoder, ComponentMetadata md) throws IOException {
        List<String> statusScheme = md.getStatusScheme();
        encoder.writeSmallInt(statusScheme.size());
        for (String s : statusScheme) {
            encoder.writeString(s);
        }
    }

     */
    boolean isMissing();

    boolean isChanging();

    @Nullable
    String getStatus();

    @Nullable
    List<String> getStatusScheme();

    ImmutableList<? extends VirtualComponentIdentifier> getPlatformOwners();

    @Override
    ImmutableAttributes getAttributes();

    public boolean isChanging() {
        return false;
    }

    @Override
    public String getStatus() {
        return null;
    }

    @Override
    public List<String> getStatusScheme() {
        return null;
    }

    @Override
    public ImmutableList<? extends VirtualComponentIdentifier> getPlatformOwners() {
        return ImmutableList.of();
    }

    @Override

     * @param changing whether the component is changing or immutable
     */
    void setChanging(boolean changing);

    /**
     * Sets the status of the component. Must
     * match one of the values in {@link #getStatusScheme()}.
     *
     * @param status the status of the component
     */
    void setStatus(String status);

    /**
     * Sets the status scheme of the component. Values are ordered

        this.moduleVersionId = metadata.getModuleVersionId();
        this.changing = metadata.isChanging();
        this.missing = metadata.isMissing();
        this.statusScheme = metadata.getStatusScheme();
        this.moduleSources = MutableModuleSources.of(metadata.getSources());
        this.variants = metadata.getVariants();
        this.attributesFactory = metadata.getAttributesFactory();

    }

    def "can use a component metadata processor to tweak user provided metadata"() {
        def processedMetadata = Mock(ComponentMetadata) {
            getStatus() >> 'from rule'
            getStatusScheme() >> ['from', 'rule']
        }
        given:
        resolveState.id >> id
        resolveState.componentMetadataProcessorFactory >> Mock(ComponentMetadataProcessorFactory) {

            return false
        }

        @Override
        String getStatus() {
            return "integration"
        }

        @Override
        List<String> getStatusScheme() {
            return ["integration"]
        }

        @Override
        AttributeContainer getAttributes() {
            return ImmutableAttributes.EMPTY
        }
    }

        0 * _

    }

    def resolvedWithStatus(String status, Map<String, ?> attributes) {
        def meta = Stub(ModuleComponentResolveMetadata) {
            getStatusScheme() >> ["integration", "milestone", "release"]
            getStatus() >> status
            getAttributes() >> AttributeTestUtil.attributes(attributes)
        }
        def state = Stub(ModuleComponentGraphResolveState) {

            encoder.writeBoolean(metadata.isChanging());
            encoder.writeBoolean(metadata.isExternalVariant());
            encoder.writeString(metadata.getStatus());
            writeStringList(metadata.getStatusScheme());
            moduleSourcesSerializer.write(encoder, metadata.getSources());
        }

        private void writeId(ModuleComponentIdentifier componentIdentifier) throws IOException {