dependency-management-resolution.png...

import org.gradle.internal.component.resolution.failure.exception.AbstractResolutionFailureException
import org.gradle.internal.component.resolution.failure.exception.ArtifactVariantSelectionException
import org.gradle.internal.component.resolution.failure.exception.ConfigurationSelectionException
import org.gradle.internal.component.resolution.failure.exception.VariantSelectionException

        ImmutableList.Builder<String> resolutions = ImmutableList.builder();

        if (throwable instanceof ResolutionProvider) {
            resolutions.addAll(((ResolutionProvider) throwable).getResolutions());
        }

        for (Throwable cause : getCauses(throwable)) {
            resolutions.addAll(getResolutions(cause));
        }

        return resolutions.build();
    }

    @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"));

     * in the selection of that module contain at least one dynamic version, then resolution will fail if the resolution
     * result can change because of this version selector.
     *
     * This can be used in cases you want to make sure your build is reproducible, <i>without</i> relying on
     * dependency locking.
     *
     * @return this resolution strategy
     * @since 6.1
     */
    ResolutionStrategy failOnDynamicVersions();

import org.jetbrains.kotlin.analysis.api.resolution.KaCompoundAccessCall
import org.jetbrains.kotlin.analysis.api.resolution.KaCompoundArrayAccessCall
import org.jetbrains.kotlin.analysis.api.resolution.KaCompoundVariableAccessCall
import org.jetbrains.kotlin.analysis.api.resolution.KaDelegatedConstructorCall
import org.jetbrains.kotlin.analysis.api.resolution.KaErrorCallInfo

 * this class to use jCIFS properly. Name resolusion is
 * handled internally to the <code>jcifs.smb1.smb1</code> package.
 * <p>
 * This class is a wrapper for both {@link jcifs.smb1.netbios.NbtAddress}
 * and {@link java.net.InetAddress}. The name resolution mechanisms
 * used will systematically query all available configured resolution
 * services including WINS, broadcasts, DNS, and LMHOSTS. See

import java.util.stream.Collectors;

/**
 * Holds the resolution state for a local component. The state is calculated as required, and an instance can be used for multiple resolutions across a build tree.
 *
 * <p>The aim is to create only a single instance of this type per project and reuse that for all resolution that happens in a build tree. This isn't quite the case yet.
 */

import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor.AssessedCandidate;
import org.gradle.internal.component.resolution.failure.ResolutionFailureDescriberRegistry;
import org.gradle.internal.component.resolution.failure.describer.ResolutionFailureDescriber;

kind: ServiceEntry
metadata:
  name: app
  namespace: app
spec:
  hosts:
  - app.com
  ports:
  - number: 80
    name: http
    protocol: HTTP
  resolution: {{.Resolution}}
  endpoints:
{{- if eq .Resolution "DNS" }}
  - address: app.com
{{- else }}
  - address: 1.1.1.1
{{- end }}
---
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: excluded