}
        }

        buildFile << """
            configurations {
                conf.dependencies.clear()
            }

            dependencies {
                conf(platform('org.test:platform:1.0'))
                conf 'org.test:depD:1.0'
                conf 'org.test:depF:1.0'
            }
"""
        when:
        succeeds 'checkDeps'

        then:

                    artifact source: customDocsTask.outputFile, name: "docs", extension: "htm", builtBy: customDocsTask
                    artifact source: regularFileTask.outputFile, name: "regular", extension: "txt"
                    artifact source: customJar, extension: "war", type: "web-archive", conf: "*"
                }
            }
""")
        when:

        }
        buildFile << """
            def customAttr = Attribute.of('custom', String)

            dependencies {
                conf "org:testA:latest.release"
                conf "org:testB:latest.release"
            }

            configurations.conf.attributes.attribute(customAttr, 'bar')
        """

        when:
        supplierInteractions.expectGetMetadata('org', 'testA') // one network request for A

	ret := sets.New[string]()

	for conf := range configs {
		if conf.Kind == kind {
			ret.Insert(conf.Name)
		}
	}

	return ret
}

// ConfigNameOfKind extracts config names of the specified kind.
func ConfigNameOfKind(configs map[ConfigKey]struct{}, kind kind.Kind) sets.String {
	ret := sets.New[string]()

	for conf := range configs {
		if conf.Kind == kind {
			ret.Insert(conf.Name)
		}
	}

            ConfigurationGraphResolveState conf = component.getConfiguration(name);
            if (conf == null) {
                return null;
            }
            assert conf.getMetadata().isCanBeConsumed() : "External components' configurations are always consumable";
            return conf.asVariant();
        }
    }

	kubeletphase.TryStartKubelet()

	// Now the kubelet will perform the TLS Bootstrap, transforming /etc/kubernetes/bootstrap-kubelet.conf to /etc/kubernetes/kubelet.conf
	// Wait for the kubelet to create the /etc/kubernetes/kubelet.conf kubeconfig file. If this process
	// times out, display a somewhat user-friendly message.
	waiter := apiclient.NewKubeWaiter(nil, 0, os.Stdout)

                    dependencyToLockIds.compute(dependency, (k, v) -> {
                        List<String> confs = v;
                        if (v == null) {
                            confs = new ArrayList<>();
                        }
                        confs.add(entry.getKey());
                        return confs;
                    });
                }
            }
        }
    }

// EnsureAdminClusterRoleBinding constructs a client from admin.conf and optionally
// constructs a client from super-admin.conf if the file exists. It then proceeds
// to pass the clients to EnsureAdminClusterRoleBindingImpl. The function returns a
// usable client from admin.conf with RBAC properly constructed or an error.

        GradleMetadataResolveRunner.useIvy() ? 'integration' : 'release'
    }

    def setup() {
        buildFile << """
dependencies {
    conf 'org.test:projectA:1.0'
}

task resolve(type: Sync) {
    from configurations.conf
    into 'libs'
}
"""
        executer.withArgument("-Ddebug.modulesource=true")
    }

    def "rule is cached across builds"() {
        repository {

        AbstractRoleBasedConfigurationCreationRequest request = new NoContextRoleBasedConfigurationCreationRequest(name, role);

        Configuration conf = findByName(request.getConfigurationName());
        if (null != conf) {
            return request.verifyExistingConfigurationUsage(conf);
        } else {
            return migratingUnlocked(request.getConfigurationName(), request.getRole());
        }
    }

    @Override