import java.io.File;
import java.util.Set;

public class IvyNormalizedPublication {

    private final String name;
    private final File ivyDescriptorFile;
    private final Set<IvyArtifact> allArtifacts;
    private final ModuleVersionIdentifier coordinates;

    public IvyNormalizedPublication(String name, ModuleVersionIdentifier coordinates, File ivyDescriptorFile, Set<IvyArtifact> allArtifacts) {

    def "delegates when publication is valid"() {
        when:
        def descriptor = ivyDescriptor()
        descriptor.branch = "the-branch"
        descriptor.status = "release"
        def publication = new IvyNormalizedPublication("pub-name", coordinates, ivyFile(descriptor), emptySet())

        and:
        publisher.publish(publication, repository)

        then:
        delegate.publish(publication, repository)
    }

    }

    @Override
    public void publish(IvyNormalizedPublication publication, IvyArtifactRepository repository) {
        validateMetadata(publication);
        validateArtifacts(publication);
        checkNoDuplicateArtifacts(publication);
        delegate.publish(publication, repository);
    }

    private void validateMetadata(IvyNormalizedPublication publication) {

import org.gradle.api.publish.ivy.internal.publisher.IvyNormalizedPublication
import org.gradle.test.fixtures.AbstractProjectBuilderSpec

import static org.gradle.api.tasks.TaskPropertyTestUtils.getInputFiles

class PublishToIvyRepositoryTest extends AbstractProjectBuilderSpec {

    PublishToIvyRepository publish

    def normalizedPublication = Mock(IvyNormalizedPublication)

    def publication = Mock(IvyPublicationInternal) {

import org.gradle.api.publish.internal.PublicationInternal;
import org.gradle.api.publish.ivy.IvyArtifact;
import org.gradle.api.publish.ivy.IvyPublication;
import org.gradle.api.publish.ivy.internal.publisher.IvyNormalizedPublication;
import org.gradle.api.tasks.TaskProvider;

public interface IvyPublicationInternal extends IvyPublication, PublicationInternal<IvyArtifact> {

    @Override
    IvyModuleDescriptorSpecInternal getDescriptor();

        }.run();
    }

    static class PublishSpec {

        private final RepositorySpec repository;
        private final IvyNormalizedPublication publication;

        public PublishSpec(
            RepositorySpec repository,
            IvyNormalizedPublication publication
        ) {
            this.repository = repository;
            this.publication = publication;
        }
    }

import org.gradle.api.artifacts.repositories.IvyArtifactRepository;

/**
 * Used by the `ivy-publish` plugin to publish Ivy modules.
 */
public interface IvyPublisher {
    void publish(IvyNormalizedPublication publication, IvyArtifactRepository repository);

        this.ivyPublisher = ivyPublisher;
        this.ivyContextManager = ivyContextManager;
    }

    @Override
    public void publish(final IvyNormalizedPublication publication, final IvyArtifactRepository repository) {
        ivyContextManager.withIvy(new Action<Ivy>() {
            @Override
            public void execute(Ivy ivy) {

    private final NetworkOperationBackOffAndRetry<Void> networkOperationBackOffAndRetry = new NetworkOperationBackOffAndRetry<>();

    @Override
    public void publish(IvyNormalizedPublication publication, IvyArtifactRepository repository) {
        IvyResolver publisher = ((DefaultIvyArtifactRepository) repository).createPublisher();

        this.project = project;
        this.duplicatePublicationTracker = duplicatePublicationTracker;
    }

    public void checkCanPublish(IvyNormalizedPublication publication, @Nullable URI repositoryLocation, String repositoryName) {