public String getName() {
        return name;
    }

    @Override
    public TaskProvider<Test> getTestTask() {
        return testTask;
    }

    @Override
    public TaskDependency getBuildDependencies() {
        return taskDependencyFactory.visitingDependencies(context -> context.add(getTestTask()));
    }

        super(identifier, publicType);
        this.source = source;
        super.builtBy(source.getBuildDependencies());
    }

    protected String getLanguageName() {
        return guessLanguageName(getTypeName());
    }

    private static synchronized String guessLanguageName(String typeName) {

    public Object getInputProperties() {
        return null;
    }

    @Override
    public FileCollection getInputFiles() {
        return null;
    }

    @Override
    public TaskDependency getBuildDependencies() {
        return TaskDependencyInternal.EMPTY;
    }

        then:
        decorator.classifier == null
    }

    def "if an explicit #field is set don't query the publish artifact"() {
        def delegate = Mock(PublishArtifact) {
            getBuildDependencies() >> Stub(TaskDependency)
        }
        def decorator = new DecoratingPublishArtifact(TestFiles.taskDependencyFactory(), delegate)
        decorator."$field" = 'foo'

        when:
        decorator."$field"

        Object... dependencies
    ) {
        taskDependency = taskDependencyFactory.configurableDependency(ImmutableSet.copyOf(dependencies));
    }

    @Override
    public TaskDependency getBuildDependencies() {
        return taskDependency;
    }

    public AbstractPublishArtifact builtBy(Object... tasks) {
        taskDependency.add(tasks);
        return this;
    }

    @Override

    protected String getDefaultClassifier() {
        return publishArtifact.getClassifier();
    }

    @Override
    protected TaskDependency getDefaultBuildDependencies() {
        return publishArtifact.getBuildDependencies();
    }

    @Override
    public boolean shouldBePublished() {
        return PublishArtifactInternal.shouldBePublished(publishArtifact);
    }

    }

    @Override
    public void builtBy(Object... tasks) {
        additionalBuildDependencies.add(tasks);
    }

    @Override
    public TaskDependency getBuildDependencies() {
        return allBuildDependencies;
    }

    protected abstract TaskDependency getDefaultBuildDependencies();

    @Override
    public String toString() {

        }
        return file;
    }

    @Override
    public File asFile() {
        return asFile(Charset.defaultCharset().name());
    }

    @Override
    public TaskDependency getBuildDependencies() {
        return TaskDependencyInternal.EMPTY;
    }

    @Override
    public Object getInputProperties() {
        return string;
    }

    @Override
    public FileCollection getInputFiles() {

        this.buildTask = buildTask;
        if (buildTask != null) {
            buildTask.dependsOn(buildTaskDependencies);
        }
    }

    @Override
    public TaskDependency getBuildDependencies() {
        // TODO maybe inject the task dependency factory into this type hierarchy, too
        final TaskDependencyFactory taskDependencyFactory = DefaultTaskDependencyFactory.withNoAssociatedProject();

        return id.getComponentIdentifier();
    }

    @Override
    public IvyArtifactName getName() {
        return id.getName();
    }

    @Override
    public TaskDependency getBuildDependencies() {
        return TaskDependencyInternal.EMPTY;
    }

    @Override
    public Optional<ComponentArtifactMetadata> getAlternativeArtifact() {
        return Optional.ofNullable(alternativeArtifact);
    }