* There is no validation that an ignored dependency is present in any configuration resolution.
* If the dependency is present in lock state, loading it will filter out the dependency.
* If the dependency is present in the resolution result, it will be ignored when validating that resolution matches the lock state.
* Finally, if the dependency is present in the resolution result and the lock state is persisted, it will be absent from the written lock state.

        1 * owner.getCapitalizedDisplayName() >> "Owner"
        ex.message == 'Locking strict mode: Owner is locked but does not have lock state.'
        ex.resolutions == ["To create the lock state, run a task that performs dependency resolution and add '--write-locks' to the command line.",

		})
	}
}

// Validates the behavior when Service resolution type is updated after initial EDS push.
// See https://github.com/istio/istio/issues/18355 for more details.
func TestEDSServiceResolutionUpdate(t *testing.T) {
	for _, resolution := range []model.Resolution{model.DNSLB, model.DNSRoundRobinLB} {
		t.Run(fmt.Sprintf("resolution_%s", resolution), func(t *testing.T) {

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

[[resolution_rules]]
= Customizing resolution of a dependency directly

This section covers mechanisms Gradle offers to directly influence the behavior of the dependency resolution engine.

              <exclude>org.apache.maven.model.resolution.InvalidRepositoryException#getRepository():METHOD_RETURN_TYPE_CHANGED</exclude>
              <exclude>org.apache.maven.model.resolution.InvalidRepositoryException#InvalidRepositoryException(java.lang.String,org.apache.maven.model.Repository,java.lang.Throwable):CONSTRUCTOR_REMOVED</exclude>

import org.eclipse.aether.repository.WorkspaceReader;
import org.eclipse.aether.resolution.MetadataRequest;
import org.eclipse.aether.resolution.MetadataResult;
import org.eclipse.aether.resolution.VersionRangeRequest;
import org.eclipse.aether.resolution.VersionRangeResolutionException;
import org.eclipse.aether.resolution.VersionRangeResult;
import org.eclipse.aether.spi.synccontext.SyncContextFactory;

        1 -> {
            val resolution = overloads.single()
            doProduceAndHandleFunctionResult(resolution, argResolutions.value, functionCall, resolution.receiver)
        }

        else -> {
            errorCollector.collect(ResolutionError(functionCall, ErrorReason.AmbiguousFunctions(overloads)))
            null
        }
    }

    // TODO: check the resolution order with the Kotlin spec
    private

[[sub:terminology_resolution_rule]]
== Resolution rule

A resolution rule influences the behavior of how a <<#sub:terminology_dependency,dependency>> is resolved directly.
Resolution rules are defined as part of the build logic.
For more information, see the section on <<resolution_rules.adoc#resolution_rules,customizing resolution of a dependency directly>>.

[[sub:terminology_transitive_dependency]]

import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.ArtifactRequest;
import org.eclipse.aether.resolution.ArtifactResolutionException;
import org.eclipse.aether.resolution.VersionRangeRequest;
import org.eclipse.aether.resolution.VersionRangeResolutionException;
import org.eclipse.aether.resolution.VersionRangeResult;

/**

import spock.lang.Issue

/**
 * Common location for resolution tests that are related to user-reported issues.
 *
 * Once these issues are resolved, we should make sure to  move these tests to a
 * file more appropriate for the feature they are testing.
 */
class ResolutionIssuesIntegrationTest extends AbstractIntegrationSpec {

    @NotYetImplemented
    def "resolution hits isConstraint assertion"() {