* 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();

        componentResult.id.displayName == componentIdentifier.displayName
        componentResult instanceof UnresolvedComponentResult
        UnresolvedComponentResult unresolvedComponentResult = (UnresolvedComponentResult) componentResult
        unresolvedComponentResult.failure instanceof IllegalArgumentException
        unresolvedComponentResult.failure.message == failureMessage

        where:

        """
        // Check unresolved component result
        UnresolvedComponentResult unresolvedComponentResult = (UnresolvedComponentResult)componentResult
        assert unresolvedComponentResult.failure instanceof ${expectedException.getClass().name}
        assert unresolvedComponentResult.failure.message == "$expectedException.message"
"""
}

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

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

public class DefaultUnresolvedComponentResult implements UnresolvedComponentResult {
    private final ComponentIdentifier componentIdentifier;
    private final Throwable failure;

import org.gradle.api.artifacts.result.UnresolvedComponentResult
import spock.lang.Specification

class DefaultArtifactResolutionResultTest extends Specification {
    ComponentArtifactsResult componentArtifactsResult1 = Mock()
    ComponentArtifactsResult componentArtifactsResult2 = Mock()
    UnresolvedComponentResult unresolvedComponentResult1 = Mock()
    UnresolvedComponentResult unresolvedComponentResult2 = Mock()

import org.gradle.api.artifacts.result.ArtifactResult
import org.gradle.api.artifacts.result.ComponentArtifactsResult
import org.gradle.api.artifacts.result.ResolutionResult
import org.gradle.api.artifacts.result.UnresolvedComponentResult
import org.gradle.api.artifacts.type.ArtifactTypeContainer
import org.gradle.api.attributes.AttributeMatchingStrategy
import org.gradle.api.attributes.AttributesSchema

     *
     * <ul>
     *     <li>{@link ComponentArtifactsResult} for any component that could be resolved in the set of repositories.</li>
     *     <li>{@link UnresolvedComponentResult} for any component that could not be resolved from the set of repositories.</li>
     * </ul>
     * @return the set of results for all requested components
     */
    Set<ComponentResult> getComponents();

import org.gradle.api.artifacts.result.ArtifactResult
import org.gradle.api.artifacts.result.ComponentArtifactsResult
import org.gradle.api.artifacts.result.ResolutionResult
import org.gradle.api.artifacts.result.UnresolvedComponentResult
import org.gradle.api.artifacts.type.ArtifactTypeContainer
import org.gradle.api.attributes.AttributeMatchingStrategy
import org.gradle.api.attributes.AttributesSchema

        assert componentResult.id.group == "${id.group}"
        assert componentResult.id.module == "${id.module}"
        assert componentResult.id.version == "${id.version}"
        assert componentResult instanceof UnresolvedComponentResult
        def failure = componentResult.failure
"""
        if (GradleContextualExecuter.configCache) {
            buildFile << """
task verify {
    def result = provider {
        $resolveAndCheck