given:
        mainProjectDir.file("app/build.gradle") << """
            tasks.register("resolve", Resolve) {
                artifactFiles.from(configurations.getByName("compileClasspath"))
            }
        """

        expect:
        fails "build"
        failure.assertHasCause("Could not resolve all dependencies for configuration ':app:runtimeClasspath'")

    }
    implementation("org.apache.commons:commons-lang3:latest.rc")
}
// end::custom-status-scheme[]

tasks.register("compileClasspathArtifacts") {
    val compileClasspath: FileCollection = configurations["compileClasspath"]
    doLast {
        compileClasspath.filter { !it.name.startsWith("commons-lang3") }.forEach { println(it.name) }
    }
}
tasks.register("failRuntimeClasspathResolve") {

        getGradleApiInfoJarPrefix().convention(GRADLE_API_INFO_JAR);
    }

    @Input
    public abstract Property<String> getGradleApiInfoJarPrefix();

    @CompileClasspath
    public abstract ConfigurableFileCollection getCurrentDistributionJars();

    @CompileClasspath
    public abstract ConfigurableFileCollection getBaselineDistributionJars();

    @OutputFile
    public abstract RegularFileProperty getCurrentUpgradedProperties();

 * limitations under the License.
 */

package org.gradle.api.internal.tasks.properties;

import org.gradle.api.tasks.Classpath;
import org.gradle.api.tasks.CompileClasspath;
import org.gradle.api.tasks.InputFiles;
import org.gradle.internal.execution.model.annotations.ModifierAnnotationCategory;
import org.gradle.internal.properties.annotations.PropertyTypeResolver;

        when:
        scalaPlugin.apply(project)

        then:
        def task = project.tasks['compileScala']
        task.setClasspath(project.sourceSets.main.compileClasspath)

        SourceSet mainSourceSet = project.sourceSets.main
        task  instanceof ScalaCompile
        task.classpath.files as List == []
        task.source as List == mainSourceSet.scala  as List

        buildFile << """
            configurations.compileClasspath.attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 5)
        """

        when:
        module.pom.expectGet()
        module.moduleMetadata.expectGet()

        fails ':checkDeps'

        then:
        failure.assertHasErrorOutput('''> Could not resolve all files for configuration ':compileClasspath'.
   > Could not resolve org:producer:1.0.

        !compileOnly.canBeResolved
        compileOnly.transitive

        when:
        def compileClasspath = project.configurations.getByName(JvmConstants.COMPILE_CLASSPATH_CONFIGURATION_NAME)

        then:
        compileClasspath.extendsFrom == toSet(compileOnly, implementation)
        !compileClasspath.visible
        compileClasspath.transitive

        when:

        buildFile << """
            apply plugin: 'java'
            ${repoBlock.replaceAll('<<URL>>', mavenHttpRepo.uri.toASCIIString())}
            task resolve {
                def files = configurations.compileClasspath
                doLast { files.files }
            }
        """
        if (deprecationWarning) {
            executer.expectDocumentedDeprecationWarning(deprecationWarning)
        }

        when:

            }

            task resolve {
                doLast {
                    println configurations.compileClasspath.incoming.files.files
                }
            }
"""

        when:
        succeeds 'dependencyInsight', '--configuration', 'compileClasspath', '--dependency', ':'

        then:
        outputContains("Could not resolve project :.")
    }

        !compileOnly.visible
        compileOnly.transitive

        when:
        def compileClasspath = project.configurations.getByName(JvmConstants.COMPILE_CLASSPATH_CONFIGURATION_NAME)

        then:
        compileClasspath.extendsFrom == toSet(compileOnly, implementation)
        !compileClasspath.visible
        compileClasspath.transitive

        when: