package main

import "testshared/dep3"

func main() {
	dep3.D3()

package lib

import "runtime/debug"

func init() {
	m, ok := debug.ReadBuildInfo()
	if !ok {
		panic("failed debug.ReadBuildInfo")
	}
	println("mod", m.Main.Path, m.Main.Version)
	for _, d := range m.Deps {
		println("dep", d.Path, d.Version, d.Sum)
		if r := d.Replace; r != nil {
			println("=>", r.Path, r.Version, r.Sum)
		}
	}
}

-- x/main.go --
package main

import (
	"rsc.io/quote"
	_ "x/lib"
)

}

repositories {
    maven {
        name 'repo'
        url '${mavenRepo.uri}'
    }
}

configurations {
    lockedConf {
        defaultDependencies { deps ->
            deps.add(project.dependencies.create('org:foo:1.0'))
        }
    }
}

task copyFiles(type: Copy) {
    from configurations.lockedConf
    into 'build/copied'
}
"""
        when:

    doLast {
        file('b.jar').text = 'some jar'
    }
}

task otherJar(type: Jar) {
    destinationDirectory = buildDir
}

configurations {
    deps
    archives {
        extendsFrom deps
    }
}
dependencies { deps files('b.jar') { builtBy jar } }
artifacts { archives otherJar }
'''

        when:
        run("doStuff")

        then:

            for line in lines:
                for dep in components:
                    if dep == component:
                        continue
                    if ("k8s.io/" + dep + " =>") not in line:
                        continue
                    print(("\t"+dep))
                    if dep not in all_dependencies[component]:
                        all_dependencies[component].append(dep)
    return all_dependencies

        then:
        metadata.dependencies.size() == 3

        def dep1 = metadata.dependencies[0]
        dep1.selector == moduleId('group-two', 'artifact-one', '11')
        dep1.scope == MavenScope.Compile

        def dep2 = metadata.dependencies[1]
        dep2.selector == moduleId('group-two', 'artifact-three', '11')
        dep2.scope == MavenScope.Compile

        def inheritedDep = metadata.dependencies[2]

	for _, dep := range deps {
		for _, ownerRef := range dep.owners {
			if ownerRef.UID != verifiedAbsentIdentity.UID {
				// skip references that aren't the uid we care about
				continue
			}

			if ownerReferenceMatchesCoordinates(ownerRef, verifiedAbsentIdentity.OwnerReference) {
				if absentIdentityIsClusterScoped || verifiedAbsentIdentity.Namespace == dep.identity.Namespace {

            configurations.res.canBeResolved = true
            configurations.res.canBeDeclared = false

            configurations.dep.canBeConsumed = false
            configurations.dep.canBeResolved = false
            configurations.dep.canBeDeclared = true
        """

        expect:
        expectConsumableChanging(":cons", true)
        expectResolvableChanging(":cons", false)

		for obj, d := range check.objMap {
			// only print objects that may appear in the dependency graph
			if obj, _ := obj.(dependency); obj != nil {
				if len(d.deps) > 0 {
					fmt.Printf("\t%s depends on\n", obj.Name())
					for dep := range d.deps {
						fmt.Printf("\t\t%s\n", dep.Name())
					}
				} else {
					fmt.Printf("\t%s has no dependencies\n", obj.Name())
				}
			}
		}
		fmt.Println()

		for obj, d := range check.objMap {
			// only print objects that may appear in the dependency graph
			if obj, _ := obj.(dependency); obj != nil {
				if len(d.deps) > 0 {
					fmt.Printf("\t%s depends on\n", obj.Name())
					for dep := range d.deps {
						fmt.Printf("\t\t%s\n", dep.Name())
					}
				} else {
					fmt.Printf("\t%s has no dependencies\n", obj.Name())
				}
			}
		}
		fmt.Println()