id("maven-publish")
            }

            group = 'group'
            version = '1.0'

            tasks.compileJava {
                // Avoid resolving the classpath when caching the configuration
                classpath = files()
            }

            dependencies {
                api('org.test:non-transitive:1.0') { transitive = false }
                api 'org.test:artifact-only:1.0@jar'

                    List<String> classpath;
                    if (isJava9) {
                        classpath = Arrays.stream(System.getProperty("java.class.path").split(Pattern.quote(File.pathSeparator)))
                            .map(path -> new File(path).getName())
                            .collect(Collectors.toList());
                    } else {

    }
  }
}
        """

        // Classpath
        def classpath = getClasspath()
        classpath.assertHasLibs('foo-1.0.jar', 'bar-1.0.jar', 'baz-1.0.jar')
        classpath.lib('foo-1.0.jar').assertIsDeployedTo('/WEB-INF/lib')
        classpath.lib('bar-1.0.jar').assertIsDeployedTo('/WEB-INF/lib')
        classpath.lib('baz-1.0.jar').assertIsExcludedFromDeployment()

        // Facets

import org.gradle.api.GradleException;
import org.gradle.api.UncheckedIOException;
import org.gradle.api.internal.classpath.DefaultModuleRegistry;
import org.gradle.api.internal.classpath.ModuleRegistry;
import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;
import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.concurrent.CompositeStoppable;
import org.gradle.internal.installation.CurrentGradleInstallation;

        server.start()
    }

    @Unroll("jars on buildscript classpath can change (loopNumber: #loopNumber)")
    def "jars on buildscript classpath can change"() {
        given:
        buildFile << '''
            buildscript {
                repositories { flatDir { dirs 'repo' }}
                dependencies { classpath name: 'test', version: '1.3-BUILD-SNAPSHOT' }
            }

            task hello {

 * stored in the given [outputDir].
 */
internal
class ResidualProgramCompiler(
    private val outputDir: File,
    private val compilerOptions: KotlinCompilerOptions,
    private val classPath: ClassPath = ClassPath.EMPTY,
    private val originalSourceHash: HashCode,
    private val programKind: ProgramKind,
    private val programTarget: ProgramTarget,
    private val implicitImports: List<String> = emptyList(),

     *
     * @param classpath the class path to search
     * @param appendix the appendix to search for
     * @return a Scala Jar file with the specified appendix
     */
    @Nullable
    public File findScalaJar(Iterable<File> classpath, String appendix) {
        return ScalaRuntimeHelper.findScalaJar(classpath, appendix);
    }

    /**

                doLast {
                    assert test.testFramework instanceof ${JUnitPlatformTestFramework.canonicalName}
                    assert classpath.size() == 8
                    assert classpath.any { it.name =~ /junit-platform-launcher-.*.jar/ }
                    assert classpath.any { it.name == "junit-jupiter-${JUnitJupiterTestToolchain.DEFAULT_VERSION}.jar" }
                }
            }
        """

        expect:

        target: Project,
        script: String,
        classPath: ClassPath = testRuntimeClassPath,
        buildAccessorsFor: (TypedProjectSchema, ClassPath, File, File) -> Unit = ::buildAccessorsFor
    ) {

        val srcDir = newFolder("src")
        val binDir = newFolder("bin")

        buildAccessorsFor(schema, classPath, srcDir, binDir)

        eval(
            script = script,

    }

    /**
     * Returns the classpath used to locate classes referenced by the documented sources.
     *
     * @return The classpath used to locate classes referenced by the documented sources
     */
    @Classpath
    public FileCollection getClasspath() {
        return classpath;
    }

    /**
     * Sets the classpath used to locate classes referenced by the documented sources.
     */