*/
package org.gradle.api.artifacts.result;

import org.gradle.api.artifacts.component.ComponentIdentifier;

/**
 * The result of resolving a component.
 *
 * @since 2.0
 */
public interface ComponentResult {
    /**
     * <p>Returns the identifier of this component. This can be used to uniquely identify the component within the current build, but it is not necessarily unique between
     * different builds.
     *

                val componentResult: ResolvedComponentResult = result.selected
                val componentIdentifier: ComponentIdentifier = componentResult.id
                val node: String = "${calculateIndentation(level)}- ${componentIdentifier.displayName} (${componentResult.selectionReason})"
                logger.quiet(node)
                traverseDependencies(level + 1, componentResult.dependencies)

import org.gradle.api.artifacts.result.ComponentResult;

import java.util.LinkedHashSet;
import java.util.Set;

public class DefaultArtifactResolutionResult implements ArtifactResolutionResult {
    private final Set<ComponentResult> componentResults;

    public DefaultArtifactResolutionResult(Set<ComponentResult> componentResults) {
        this.componentResults = componentResults;
    }

    @Override

        // Check generic component result
        def componentResult = result.components.iterator().next()
        assert componentResult.id.displayName == "${id.displayName}"
        assert componentResult.id.group == "${id.group}"
        assert componentResult.id.module == "${id.module}"
        assert componentResult.id.version == "${id.version}"
        assert componentResult instanceof ComponentArtifactsResult

                ResolvedComponentResult componentResult = result.selected
                ComponentIdentifier componentIdentifier = componentResult.id
                String node = calculateIndentation(level) + "- $componentIdentifier.displayName ($componentResult.selectionReason)"
                logger.quiet node
                traverseDependencies(level + 1, componentResult.dependencies)

    }

    private String createComponentResultVerificationCode() {
        """
        // Check generic component result
        def componentResult = result.components.iterator().next()
        assert componentResult.id.displayName == '$id.displayName'
        assert componentResult instanceof $expectedComponentResult.name
"""
    }

    private String createUnresolvedComponentResultVerificationCode() {
        """

 *
 * @since 2.0
 */
public interface ArtifactResolutionResult {
    /**
     * <p>Return a set of {@link ComponentResult} instances representing all requested components.
     *
     * <p>Each element in the returned set is declared as an opaque {@link ComponentResult}.
     *    However each element in the result will also implement one of the following interfaces:</p>
     *
     * <ul>

        then:
        result
        result.components.size() == 1
        def componentResult = result.components.iterator().next()
        componentResult.id.displayName == componentIdentifier.displayName
        componentResult instanceof UnresolvedComponentResult
        UnresolvedComponentResult unresolvedComponentResult = (UnresolvedComponentResult) componentResult
        unresolvedComponentResult.failure instanceof IllegalArgumentException

        DefaultComponentArtifactsResult componentResult = new DefaultComponentArtifactsResult(componentState.getId());
        for (Class<? extends Artifact> artifactType : artifactTypes) {
            addArtifacts(componentResult, artifactType, componentState, moduleResolveResult.getModuleVersionId(), artifactResolver);
        }
        return componentResult;
    }

 * limitations under the License.
 */
package org.gradle.api.artifacts.result;

/**
 * A component that could not be resolved.
 *
 * @since 2.0
 */
public interface UnresolvedComponentResult extends ComponentResult {
    /**
     * Returns the failure that occurred when trying to resolve the component.
     */
    Throwable getFailure();