import org.gradle.internal.component.resolution.failure.exception.VariantSelectionException;
import org.gradle.internal.component.resolution.failure.type.IncompatibleGraphVariantFailure;
import org.gradle.internal.component.resolution.failure.type.IncompatibleResolutionFailure;
import org.gradle.internal.component.resolution.failure.type.ResolutionFailure;
import org.gradle.util.GradleVersion;

        if (!(failure instanceof ModuleVersionNotFoundException) || !settingsRepositoriesIgnored()) {
            return failure;
        }

        ImmutableList<String> resolutions = ImmutableList.of(
            "The project declares repositories, effectively ignoring the repositories you have declared in the settings.\n" +

        return formatter.toString();
    }

    @Override
    protected List<String> buildResolutions(String... resolutions) {
        List<String> result = new ArrayList<>(super.buildResolutions(resolutions));
        result.add(suggestDependencyInsight());
        return result;
    }

import javax.annotation.concurrent.ThreadSafe;

/**
 * A specialized {@link ComponentGraphResolveState} for external components.
 *
 * <p>Instances of this type are cached and reused for multiple graph resolutions, possibly in parallel. This means that the implementation must be thread-safe.
 */
@ThreadSafe
public interface ModuleComponentGraphResolveState extends ExternalComponentGraphResolveState {
    @Override

                }
            }
        """

        expect:
        succeeds "addConfigs"
    }

    def "can remove and add configurations between resolutions"() {
        given:
        mavenRepo.module("org", "foo", "1.0").publish()

        buildFile << """
            repositories {
                maven { url '$mavenRepo.uri' }
            }

	soffset       uint32        // used by serverOffset
	singleRequest bool          // use sequential A and AAAA queries instead of parallel queries
	useTCP        bool          // force usage of TCP for DNS resolutions
	trustAD       bool          // add AD flag to queries
	noReload      bool          // do not check for config file updates
}

// serverOffset returns an offset that can be used to determine

        // The m2 installation on the integ spec is intended to verify the way Gradle interacts
        // with the system's local m2 repo, however the resolutions performed by this fixture
        // should be isolated from the build.
        def localRepoDir = temporaryFolder.testDirectory.file("maven-resolver-test-fixture-m2")
        return new ApiMavenResolver(localRepoDir, mavenRepo.uri)
    }

import java.util.List;

/**
 * A specialized {@link ComponentGraphResolveState} for local components (ie project dependencies).
 *
 * <p>Instances of this type are cached and reused for multiple graph resolutions, possibly in parallel. This means that the implementation must be thread-safe.
 */
@ThreadSafe
public interface LocalComponentGraphResolveState extends ComponentGraphResolveState {

    @Override
    public ExecutionFailure assertHasResolution(String resolution) {
        assertThat(this.resolution, containsString("> " + resolution));
        return this;
    }

    @Override
    public ExecutionFailure assertHasResolutions(String... resolutions) {
        String expected = Arrays.stream(resolutions)
            .map(resolution -> "> " + resolution)
            .collect(joining("\n"));

    /**
     * Returns the synthetic dependencies for this context. These dependencies are generated
     * by Gradle and not provided by the user, and are used for dependency locking and consistent resolution.
     * These constraints are not always used during resolution, based on which phase of execution we are in
     * (task dependencies, execution, ...)
     *