*/
@Contextual
@HasInternalProtocol
public class ResolveException extends DefaultMultiCauseException {

    /**
     * Do not call this constructor.
     *
     * @deprecated This constructor will be removed in 9.0
     */
    @Deprecated
    public ResolveException(String message, Throwable cause) {
        super(message, cause);

    private final Set<UnresolvedDependency> unresolvedDependencies;
    private final ResolveException resolutionFailure;

    public DefaultVisitedGraphResults(
        MinimalResolutionResult resolutionResult,
        Set<UnresolvedDependency> unresolvedDependencies,
        @Nullable ResolveException resolutionFailure
    ) {
        this.resolutionResult = resolutionResult;

import com.google.common.collect.ImmutableList;
import org.gradle.api.artifacts.ResolveException;

import java.util.List;

/**
 * An internal specialization of the public {@link ResolveException}. All resolve exceptions thrown
 * by Gradle are assumed to be an instance of this class.
 */
public class TypedResolveException extends ResolveException {
    private final String type;
    private final ImmutableList<String> resolutions;

     *
     * @throws ResolveException when the resolve was not successful.
     */
    void rethrowFailure() throws ResolveException;

    /**
     * Returns the files for the configuration dependencies.
     *
     * @return The artifact files of the specified dependencies.
     * @throws ResolveException when the resolve was not successful.
     * @since 3.3
     */

    @Override
    public Set<ResolvedDependency> getFirstLevelModuleDependencies() throws ResolveException {
        rethrowFailure();
        return configuration.getFirstLevelModuleDependencies();
    }

    @Override
    @Deprecated
    public Set<ResolvedDependency> getFirstLevelModuleDependencies(Spec<? super Dependency> dependencySpec) throws ResolveException {

        // the causes to avoid losing the original stack trace
        if (mappedCauses.equals(resolveException.getCauses())) {
            return resolveException;
        }

        return new TypedResolveException(resolveException.getType(), contextDisplayName, mappedCauses, resolveException.getResolutions());
    }

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.results;

import org.gradle.api.artifacts.ResolveException;
import org.gradle.api.artifacts.UnresolvedDependency;
import org.gradle.api.internal.artifacts.result.MinimalResolutionResult;

import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.configurations;

import org.gradle.api.artifacts.ResolveException;
import org.gradle.internal.Describables;
import org.gradle.internal.DisplayName;

import java.util.Collection;
import java.util.Optional;

/**

        expect:
        !results1.hasAnyFailure()
        results2.hasAnyFailure()
        results3.hasAnyFailure()
    }

    def "visits all resolution failures"() {
        given:
        def throwable = Mock(Throwable)
        def resolveEx = Mock(ResolveException)

        def unresolved = Mock(UnresolvedDependency) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal.artifacts;

import org.gradle.api.artifacts.ResolveException;
import org.gradle.api.internal.artifacts.repositories.ResolutionAwareRepository;

import java.util.List;

public interface ConfigurationResolver {

    /**