implementation project(":child")
                implementation 'org.foo:rock:1.0' //contains unresolved transitive dependency
            }
        """
        failedResolve.prepare("compileClasspath")
        createDirs("child")
        settingsFile << "include 'child'"
        def m1 = mavenHttpRepo.module('org.foo', 'hiphop').publish()
        def m2 = mavenHttpRepo.module('org.foo', 'unknown')

 *   }
 *
 *   dependencies {
 *       implementation 'org.slf4j:slf4j-api:1.7.26'
 *   }
 *
 *   //copying all dependencies attached to 'compileClasspath' into a specific folder
 *   task copyAllDependencies(type: Copy) {
 *     //referring to the 'compileClasspath' configuration
 *     from configurations.compileClasspath
 *     into 'allLibs'
 *   }
 * </pre>

                integrationTest {
                    java {
                        srcDir file('$testSrcDir')
                    }
                    compileClasspath += sourceSets.main.output + configurations.testRuntimeClasspath
                    runtimeClasspath += output + compileClasspath
                }
            }

            task integrationTest(type: Test) {

            }

            task validate {
                doLast {
                    def compileClasspath = configurations.compileClasspath.resolvedConfiguration
                    assert compileClasspath.hasError()
                    println "evaluating:"
                    compileClasspath.${expression}
                }
            }
        """

        m1.allowAll()
        m2.allowAll()

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

// tag::lock-mode[]
dependencyLocking {
    lockMode = LockMode.STRICT
}
// end::lock-mode[]

configurations {
    compileClasspath {
        resolutionStrategy.activateDependencyLocking()
    }
}

dependencies {
    implementation 'org.springframework:spring-beans:[5.0,6.0)'

                    }
                    outgoing.capability("org:optional-feature:\${version}")
                }
                compileClasspath.extendsFrom(optionalFeatureImplementation)
            }

            ${ivyTestRepository()}

            dependencies {
                optionalFeatureImplementation 'org:optionaldep:1.0'
            }

plugins {
    java
}

repositories {
    mavenCentral()
}

// tag::locking-one[]
configurations.compileClasspath {
    resolutionStrategy.deactivateDependencyLocking()
}
// end::locking-one[]

// tag::locking-deps[]
dependencies {
    implementation("org.springframework:spring-beans:[5.0,6.0)")
}

        // We have to explicitly add compileClasspath here because it may contain classes that aren't part of the compileClasspathConfiguration. In particular, compile
        // classpath of the test sourceSet contains output of the main sourceSet.
        taskMapping.map("classpath", () -> {

        project.apply(plugin: 'java')
        childProject.apply(plugin: 'java')

        eclipseClasspath.setProjectDependenciesOnly(true)
        eclipseClasspath.plusConfigurations = [project.configurations.compileClasspath, project.configurations.runtimeClasspath, project.configurations.testCompileClasspath, project.configurations.testRuntimeClasspath]

        when:
        project.dependencies.add('implementation', childProject)

        and: "args file contains remaining arguments (one per line, quoted)"
        argsFile.readLines() == ["-g", "-sourcepath", quote(""), "-proc:none", USE_UNSHARED_COMPILER_TABLE_OPTION, "-classpath", quote("${spec.compileClasspath.join(File.pathSeparator)}"), *(spec.sourceFiles*.path.collect { quote(it) })]
    }

    String defaultEmptySourcePathRefFolder() {