*/
package org.gradle.language.java.artifact;

import org.gradle.api.component.Artifact;

/**
 * An artifact containing Javadoc documentation.
 *
 * @since 2.0
 */
public interface JavadocArtifact extends Artifact {

        when:
        module.pom.expectGet()
        javadocArtifact.expectHead()
        javadocArtifact.expectGetBroken()

        then:
        fails("verify")
        failure.assertHasCause("Could not download some-artifact-1.0-javadoc.jar (some.group:some-artifact:1.0)")
        failure.assertHasCause("Could not get resource '${javadocArtifact.uri}'")

        def javadocArtifact = module.getArtifact(classifier: "my-javadoc")
        javadocArtifact.expectGetMissing()

        then:
        fails("verify")
        failure.assertHasCause("""Could not find some-artifact-1.0-my-javadoc.jar (some.group:some-artifact:1.0).
Searched in the following locations:
    ${javadocArtifact.uri}""")

        when:

import org.gradle.jvm.toolchain.JavadocTool;
import org.gradle.jvm.toolchain.internal.JavaToolchain;
import org.gradle.jvm.toolchain.internal.ToolchainToolFactory;
import org.gradle.language.java.artifact.JavadocArtifact;
import org.gradle.process.internal.ExecActionFactory;
import org.gradle.tooling.events.OperationType;
import org.slf4j.LoggerFactory;

import java.util.Collections;

import static java.util.Collections.emptyList;

                        .allDependencies.first().selected.id
                    dependencies.createArtifactResolutionQuery()
                        .forComponents(id)
                        .withArtifacts(JvmLibrary, JavadocArtifact)
                        .execute()
                }
            }
        """

        expect:
        succeeds('query')
    }

import org.gradle.api.specs.Specs;
import org.gradle.internal.jvm.JavaModuleDetector;
import org.gradle.jvm.JvmLibrary;
import org.gradle.language.base.artifact.SourcesArtifact;
import org.gradle.language.java.artifact.JavadocArtifact;

import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;

        final javadocArtifact = module.artifact(classifier: "javadoc")
        module.publish()

        when:
        useMavenRepo(repo)

        and:
        module.pom.expectGet()
        module.artifact.expectGet()

        sourceArtifact.expectHead()
        sourceArtifact.expectGetBroken()

        javadocArtifact.expectHead()
        javadocArtifact.expectGetBroken()

                    .withArtifacts(
                        JvmLibrary::class.java,
                        SourcesArtifact::class.java,
                        JavadocArtifact::class.java)
                    .execute()
                    .resolvedComponents

            inline fun <reified T : Artifact> printFileNamesOf() =
                resolvedComponents

            }
            library.setSources(sourcePaths);
            Set<Path> javaDocPaths = new LinkedHashSet<>();
            for (ResolvedArtifactResult javaDocArtifact : javaDoc) {
                javaDocPaths.add(toPath(ideaModule, javaDocArtifact.getFile()));
            }
            library.setJavadoc(javaDocPaths);
            moduleDependencies.add(library);
        }

        @Override

        this.artifactTypes << "SourcesArtifact"
        this
    }

    JvmLibraryArtifactResolveTestFixture requestingJavadoc() {
        this.artifactTypes << "JavadocArtifact"
        this
    }


    JvmLibraryArtifactResolveTestFixture clearExpectations() {
        unresolvedComponentFailure = false
        this.expectedSources = []
        this.expectedJavadoc = []