}

    @Override
    public void resolve(NativeBinaryResolveResult resolution) {
        for (NativeBinaryRequirementResolveResult requirementResolution : resolution.getPendingResolutions()) {
            DefaultLibraryResolver libraryResolver = new DefaultLibraryResolver(libraryBinaryLocator, requirementResolution.getRequirement(), resolution.getTarget());
            NativeLibraryBinary libraryBinary = libraryResolver.resolveLibraryBinary();

        when:
        def resolution = mavenResolver.resolveDependency("org", "root-first", "1.0")

        then:
        resolution.firstLevelDependencies == ["org:other-second:jar:1.0"]

        when:
        succeeds ":printFirstRuntimeClasspath"

        then:
        readClasspath("first") == resolution.artifactFileNames
    }

apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: byon
  namespace: testns
spec:
   hosts:
   - byon.test.istio.io
   ports:
   - number: 80
     name: http
     protocol: HTTP
   resolution: STATIC
   endpoints:
    - address: 127.0.0.2
      ports:
        http: 7072
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: byon
  namespace: testns
spec:

 */

package org.jetbrains.kotlin.analysis.api.fir.references

import org.jetbrains.kotlin.analysis.api.KaSession
import org.jetbrains.kotlin.analysis.api.resolution.KaSimpleFunctionCall
import org.jetbrains.kotlin.analysis.api.resolution.calls
import org.jetbrains.kotlin.analysis.api.resolution.symbol
import org.jetbrains.kotlin.analysis.api.symbols.KaFunctionSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KaSymbol

    public ArtifactVariantSelectionException(String message, ResolutionFailure failure, List<String> resolutions) {
        super(message, failure, resolutions);
    }

    public ArtifactVariantSelectionException(String message, ResolutionFailure failure, List<String> resolutions, Throwable cause) {
        super(message, failure, resolutions, cause);
    }

 * <ul>
 *     <li>{@code DEFAULT} will load the lock state and verify resolution matches it</li>
 *     <li>{@code STRICT} in addition to the {@code DEFAULT} behaviour, will fail resolution if a locked configuration does not have lock state defined</li>
 *     <li>{@code LENIENT} will load the lock state, to anchor dynamic versions, but otherwise be lenient about modifications of the dependency resolution,

 * This is a separate from {@link VariantGraphResolveMetadata} because calculating the artifacts for a variant may be expensive, and is
 * used during graph resolution only in very specific cases.
 *
 * <p>Note: only provides a limited view of the artifact metadata, exposing only that required to perform graph resolution.</p>
 */
public interface VariantArtifactGraphResolveMetadata {

        val resolution = schema.resolve("configureCustomInstance { }")
        assertTrue(runtimeInstanceFromResult(schema, resolution, configureLambdas, runtimeCustomAccessors, ::MyReceiver).myHiddenInstance.isInitialized())
    }


    @Test
    fun `accesses receiver from runtime lambda argument mapping to JVM`() {
        val resolution = schema.resolve(
            """

 */

package org.gradle.internal.component.resolution.failure.describer;

import org.gradle.api.attributes.Attribute;
import org.gradle.api.internal.DocumentationRegistry;
import org.gradle.api.internal.attributes.AttributeDescriber;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor.AssessedAttribute;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor.AssessedCandidate;

    /**
     * Returns the resolved dependency graph, performing the resolution lazily.
     *
     * <p>The lazy aspect depends on what is done with the returned {@code ResolutionResult}.</p>
     *
     * This will resolve the dependency graph but will not resolve or download the artifacts.
     *