node("leaf4")

        resolvedConf("root", [dep("root", "mid1"), dep("root", "mid2")])

        resolvedConf("mid1", [dep("mid1", "leaf1"), dep("mid1", "leaf2")])
        resolvedConf("mid2", [dep("mid2", "leaf3"), dep("mid2", "leaf4")])

        resolvedConf("leaf1", [])
        resolvedConf("leaf2", [])
        resolvedConf("leaf3", [])
        resolvedConf("leaf4", [])

        when:

                task resolveConf {
                    def files = configurations.conf
                    doLast { println path + " " + files*.name }
                }
            }
            resolveConf.dependsOn(':impl:resolveConf')
        """

        when:
        lib.ivy.expectGet()
        lib.jar.expectGet()
        run "resolveConf"

        then:

            }
        """
        buildFile << """
            dependencies {
                resolveConf project(path: ":producer", configuration: "conf")
                resolveConf project(path: ":producer", configuration: "additionalConf")
            }
            task resolve(type: Sync) {
                from(configurations.resolveConf)
                into(buildDir)
            }
        """
        when:

        dslDir.file(buildScript) << buildScriptUpdate(dsl)

        when:
        inDirectory(dslDir)
        //smoke testing if dependency resolution works fine
        run("resolveConf")

        then:
        noExceptionThrown()

        where:
        dsl      | buildScript
        'groovy' | 'build.gradle'
        'kotlin' | 'build.gradle.kts'
    }

                        }
                    }
                }
            }

            dependencies {
                conf "org:child:1.0"
            }

            task resolveConf {
                def files = configurations.conf
                def modules = provider { fired }
                doLast {
                    files.files

                    assert deps[0].requested.version == '1.3'
                }
            }
"""

        when:
        def failure = runAndFail("check", "resolveConf")

        then:
        failure.assertHasCause("Could not resolve all files for configuration ':conf'.")
        failure.assertHasCause("Could not find org.utils:api:1.123.15")
    }

                foo 'foo:bar:1.0'
                foo 'foo:bar:2.0'
            }

            task resolveConf {
                def foo = configurations.foo
                doLast {
                    foo.each { println it }
                }
            }
        """

        when:
        run "resolveConf", "dependencies"

        then:
        output.contains "foo:bar:1.0 -> 2.0"
    }

                @org.gradle.model.Mutate
                void doSomething(String s) { }
            }
        """

        when:
        fails "resolve"

        then:
        fails 'resolveConf'
        failureDescriptionStartsWith("A problem occurred evaluating root project")
        failure.assertHasCause("""Type BadRuleSource is not a valid rule source:

        settingsFile << "include 'a', 'b', 'c'"
        file('a/build.gradle') << """
            configurations { conf }
            dependencies { conf project(path: ":b", configuration: "conf") }
            task resolveConf {
                doLast {
                    //resolves at execution time, forcing 'b' to get configured
                    configurations.conf.files
                }
            }
        """

		dnsString = dnsString + fmt.Sprintf("nameserver %s\n", dns)
	}
	if c.ResolverConfig != "" {
		f, err := os.Open(c.ResolverConfig)
		if err != nil {
			klog.ErrorS(err, "Could not open resolverConf file")
		} else {
			defer f.Close()
			_, hostSearch, _, err := parseResolvConf(f)
			if err != nil {
				klog.ErrorS(err, "Error for parsing the resolv.conf file")
			} else {