val file = readFile()
        val artifactName = IvyArtifactNameSerializer.INSTANCE.read(this)
        val componentId = componentIdSerializer.read(this)
        val artifactId = ComponentFileArtifactIdentifier(componentId, file.name)

                    byConstraint()
                    artifact(name: artifactName, type: 'distribution-tgz')
                    artifact(name: artifactName, type: 'zip')
                }
                constraint('org:foo:1.0')
            }
        }

        where:
        notation                                               | artifactName | declaration

        this.componentId = componentId;
        this.sourceAttributes = sourceAttributes;
        this.targetAttributes = targetAttributes;
        this.capabilities = capabilities;
        this.artifactName = artifactName;
        this.dependenciesConfigurationIdentity = dependenciesConfigurationIdentity;
        this.transformStepNodeId = transformStepNodeId;
    }

    @Override
    public NodeType getNodeType() {

    void assertArtifact(String name, String extension, String type, String classifier) {
        def artifactName = metadata.artifactDefinitions*.artifactName.find({it.name == name})
        assert artifactName.name == name
        assert artifactName.type == type
        assert artifactName.extension == extension
        assert artifactName.classifier == classifier
    }

            actual.targetAttributes == expected.targetAttributes &&
            actual.capabilities == expected.capabilities &&
            actual.artifactName == expected.artifactName &&
            actual.dependenciesConfigurationIdentity == expected.dependenciesConfigurationIdentity
    }

    void verifyTransformationIdentity(actual, PlannedTransformStepIdentityWithoutId expected) {

            }
        }
        return false;
    }

    @Override
    public boolean excludesArtifact(ModuleIdentifier module, IvyArtifactName artifactName) {
        for (ExcludeSpec component : getComponents()) {
            if (component.excludesArtifact(module, artifactName)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean mayExcludeArtifacts() {

        def artifactName = "${artifactId}-${publishArtifactVersion}"
        if (GUtil.isTrue(classifier) && classifier != MAIN_FEATURE) {
            artifactName += "-${classifier}"
        }
        if (GUtil.isTrue(extension)) {
            artifactName += ".${extension}"
        }
        return artifactName.toString()
    }

    }

    @Override
    public PublishArtifactLocalArtifactMetadata read(Decoder decoder) throws Exception {
        ComponentIdentifier identifier = componentIdentifierSerializer.read(decoder);
        String artifactName = decoder.readString();
        String artifactExtension = decoder.readString();
        String artifactType = decoder.readString();
        String artifactClassifier = decoder.readNullableString();

    private final IvyArtifactName name;

    public MissingLocalArtifactMetadata(ComponentIdentifier componentIdentifier, IvyArtifactName artifactName) {
        this.componentIdentifier = componentIdentifier;
        this.name = artifactName;
    }

    @Override
    public String getDisplayName() {
        return name.getDisplayName() + " (" + componentIdentifier.getDisplayName() + ")";
    }

    }

    private Artifact findOrCreate(IvyArtifactName artifactName) {
        for (Artifact existingArtifact : artifacts) {
            if (existingArtifact.getArtifactName().equals(artifactName)) {
                return existingArtifact;
            }
        }
        Artifact newArtifact = new Artifact(artifactName);
        artifacts.add(newArtifact);
        return newArtifact;
    }