doLast {
        println(classpath.files)
    }
}

// tag::disabling-detached-configuration[]
tasks.register("checkDetachedDependencies") {
    val detachedConf: FileCollection = configurations.detachedConfiguration(dependencies.create("org.apache.commons:commons-lang3:3.3.1")).apply {
        resolutionStrategy.disableDependencyVerification()
    }
    doLast {
        println(detachedConf.files)
    }
}

    @Override
    ConfigurationInternal getByName(String name) throws UnknownConfigurationException;
    @Override
    ConfigurationInternal detachedConfiguration(Dependency... dependencies);

        "summary"                                                                       | "summary"
        "The detachedConfiguration1 configuration has been deprecated for consumption." | "the-detachedconfiguration-configuration-has-been-deprecated-for-consumption"
    }

    private void expectMessage(String expectedMessage) {
        def events = outputEventListener.events

        do {
            try {
                Dependency dep = resolutionServices.dependencyHandler.create(dependency)
                Configuration config = resolutionServices.configurationContainer.detachedConfiguration(dep)
                config.resolutionStrategy.disableDependencyVerification()
                return config.files
            } catch (Throwable t) {
                exceptions.add(t)

    }

    private Configuration resolveJaxb() {
        Project project = getProject();
        DependencyHandler dependencies = project.getDependencies();
        return project.getConfigurations().detachedConfiguration(
                dependencies.create("javax.xml.bind:jaxb-api:2.3.0"),
                dependencies.create("com.sun.xml.bind:jaxb-core:2.3.0.1"),
                dependencies.create("com.sun.xml.bind:jaxb-impl:2.3.0.1"),

                Configuration scalaRuntimeClasspath = isScala3 ?
                  project.getConfigurations().detachedConfiguration(getScalaCompilerDependency(scalaVersion), compilerBridgeJar, compilerInterfaceJar, getScaladocDependency(scalaVersion)) :
                  project.getConfigurations().detachedConfiguration(getScalaCompilerDependency(scalaVersion), compilerBridgeJar, compilerInterfaceJar);

        scalaClasspath.files

        then:
        GradleException e = thrown()
        e.message == "Could not resolve all files for configuration ':detachedConfiguration1'."
        e.cause.message.startsWith("Cannot resolve external dependency org.scala-lang:scala-compiler:2.10.1 because no repositories are defined.")
    }

        DependencyHandler dependencies = detachedResolver.getDependencies();
        Configuration config = detachedResolver.getConfigurations().detachedConfiguration(
            dependencies.create("org.apache.maven:maven-core:" + MAVEN_VERSION),
            dependencies.create("org.apache.maven:maven-plugin-api:" + MAVEN_VERSION),

    private
    fun findLatest(name: String, notation: String, dest: Properties) {
        val libDependencies = arrayOf(project.dependencies.create(notation))
        val templateVersionConfiguration = project.configurations.detachedConfiguration(*libDependencies)
        templateVersionConfiguration.resolutionStrategy.componentSelection.all {
            devSuffixes.forEach {
                if (it.containsMatchIn(candidate.version)) {

            attributes.attribute(artifactType, sourceDirectory)
        }

    private
    fun detachedConfigurationFor(dependency: Dependency) =
        configurations.detachedConfiguration(dependency)

    private
    fun gradleSourceDependency() = dependencies.create(
        group = "gradle",
        name = "gradle",
        version = dependencyVersion(gradleVersion),