FileCollection rtClasspath = javaModuleDetector.inferClasspath(modularity.getInferModulePath().get(), classpath);

        if (rtClasspath != null && !rtClasspath.isEmpty()) {
            allArgs.add("-cp");
            allArgs.add(CollectionUtils.join(File.pathSeparator, rtClasspath));
        }

        def cp2 = ClassPath.EMPTY

        expect:
        (cp1 + cp2).is(cp1)
    }

    def "add returns rhs when lhs is empty"() {
        def cp1 = ClassPath.EMPTY
        def cp2 = DefaultClassPath.of(new File("a.jar"))

        expect:
        (cp1 + cp2).is(cp2)
    }

    def "can add collection of files to classpath"() {
        def file1 = new File("a.jar")

            // If we are pretending that we don't have a sourcepath, the compiler will
            // look on the classpath for sources. Since we don't want to bring in any
            // sources implicitly from the classpath, we have to ignore source files
            // found on the classpath.
            if (location.equals(StandardLocation.CLASS_PATH)) {
                kinds.remove(JavaFileObject.Kind.SOURCE);
            }
        }

 * are specified by {@link WorkerProcessBuilder#sharedPackages}, but should likely be tracked in this class as well.</p>
 *
 * <p>This classpath is intended to be consumed by the {@link ForkingTestClassProcessor}.</p>
 */
public class ForkedTestClasspath {
    private final ImmutableList<File> applicationClasspath;

For details on what level of understanding Gradle has for detecting changes to classpaths and what is considered as a classpath see <<incremental_build.adoc#sec:task_input_using_classpath_annotations,this section>>.

[[filter_runtime_classpath]]
===== Filtering runtime classpaths

import org.gradle.internal.classloader.CachingClassLoader
import org.gradle.internal.classloader.DefaultHashingClassLoaderFactory
import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification

        // TODO:isolated support precompiled scripts
        IntermediateScriptModel(it, ClassPath.EMPTY, ClassPath.EMPTY, emptyList())
    }
}


private
fun buildOutputModel(scriptFile: File, classPath: ClassPath, sourcePath: ClassPath, implicitImports: List<String>, exceptions: List<Exception>) =
    StandardKotlinDslScriptModel(
        classPath.asFiles,
        sourcePath.asFiles,
        implicitImports,

     * This method was originally added in order to release the resources of the {@code classpath}
     * configurations used for resolving buildscript classpaths, as they consumed a non-negligible
     * amount of memory even after the buildscript classpath was assembled.
     * <p>
     * Future work in this area should remove the need of this method by instead caching resolution

                    ${mavenCentralRepository()}
                    dependencies {
                        // Dynamically changing the classpath here surfaces problems with the ClassLoaderCache
                        classpath "org.apache.commons:commons-lang3:\${version}"
                    }
                }

                task doStringOp {
                    doLast {

        // the entire set of framework implementation dependencies from the distribution in order to ensure that all implementation
        // dependencies on the classpath share a version. This can _still_ lead to duplicates on the classpath, but it is at least
        // avoidable if the user adds junit-platform-launcher to their test runtime classpath, which they should be doing, since