ivy.dependencies.dependency.each { dep ->
            def ivyDependency = new IvyDescriptorDependency(
                    org: dep.@org,
                    module: dep.@name,
                    revision: dep.@rev,
                    revisionConstraint: dep.@revConstraint,
                    confs: [dep.@conf],
                    transitive: dep.@transitive
            )

            dep.exclude.each { exclude ->

global:
  variant: distroless

enable:
  istiod: true

# Overrides for the `istiod-remote` dep
istiod:
  profile: ambient

# Overrides for the `ztunnel` dep
ztunnel:
  profile: ambient

# Overrides for the `cni` dep
cni:

        """
        resolve.prepare()

        and:
        dep.ivy.expectDownload()
        dep.jar.expectDownload()

        when:
        run 'checkDeps'

        then:
        progressLogger.downloadProgressLogged(dep.ivy.uri)
        progressLogger.downloadProgressLogged(dep.jar.uri)
        resolve.expectGraph {
            root(":", ":test:") {

    def "artifacts are equal when artifact identifier is equal"() {
        def dependency = dep("group", "module1", "1.2")
        def dependencySameModule = dep("group", "module1", "1.2")
        def dependency2 = dep("group", "module2", "1-beta")
        def artifactSource = Stub(CalculatedValue)
        def ivyArt = Stub(IvyArtifactName)

// tag::configuration-with-dependencies[]
configurations {
    create("implementation") {
        withDependencies {
            val dep = this.find { it.name == "to-modify" } as ExternalModuleDependency
            dep.version {
                strictly("1.2")
            }
        }
    }
}

    }

    def "delegates to TaskDependencyContainer to determine build dependencies"() {
        def dep = Mock(TaskDependencyContainer)

        given:
        1 * dep.visitDependencies(_) >> { TaskDependencyResolveContext context -> context.add(otherTask) }

        when:
        dependency.add(dep)

        then:
        dependency.getDependencies(task) == toSet(otherTask)
    }

        assert deps.size() == 1
        def dep = deps.find { it instanceof ClientModule && it.name == 'moduleOne' }
        assert dep
        assert dep.dependencies.size() == 5
        assert dep.dependencies.find { it.group == 'org.foo' && it.name == 'bar' && it.version == '1.0' && it.transitive == true }
        assert dep.dependencies.find { it.group == 'org.foo' && it.name == 'one' && it.version == '1' }

// MODULE: dep
// FILE: issue/pack/RowIcon.java
package issue.pack;

public class RowIcon {
    public static class RClass {}
}

// MODULE: main(dep)
// FILE: usage.kt
package usage

fun testJavaNestedClass(alignment: issue.pack.RowIcon.RClass) {
}

fun checkIt() {
    testJavaNestedClass(issue.pack.RowIcon.RClass())

                org.eclipse.aether.graph.Dependency dep = RepositoryUtils.toDependency(artifact, exclusions);
                if (!DependencyScope.SYSTEM.is(dep.getScope())
                        && dep.getArtifact().getFile() != null) {
                    // enable re-resolution
                    org.eclipse.aether.artifact.Artifact art = dep.getArtifact();

        and:
        //does not contain unresolved dep, contains root
        modules == [root, dep1.selected, dep2.selected, dep3.selected] as Set
    }

    def "provides hooks for iterating each module or dependency exactly once"() {
        given:
        //root -> dep1,dep2; dep1 -> dep3
        def dep = newDependency('dep1')
        def dep3 = newDependency('dep3')