MixInLegacyTypesClassLoader.Spec workerExtensionSpec = classLoaderRegistry.getGradleWorkerExtensionSpec();
        FilteringClassLoader.Spec gradleApiFilter = classLoaderRegistry.getGradleApiFilterSpec();
        VisitableURLClassLoader.Spec userSpec = getUserSpec("worker-loader", additionalClasspath, classes);

    }

    /**
     * Filters additional modules based on jar file names.
     */
    private AdditionalClasspath filterFast(Iterable<? extends File> classpath, Iterable<? extends File> modulepath, AdditionalClasspath unfiltered) {
        AdditionalClasspath mutable = new AdditionalClasspath(
            new ArrayList<>(unfiltered.applicationClasspath),
            new ArrayList<>(unfiltered.applicationModulepath),

            }
            int additionalClassPathLength = decoder.readSmallInt();
            additionalClassPath = new ArrayList<File>(additionalClassPathLength);
            for (int i = 0; i < additionalClassPathLength; i++) {
                additionalClassPath.add(new File(decoder.readString()));
            }
        } catch (EOFException e) {
            throw new UncheckedIOException(e);

                @Internal
                def additionalForkOptions = {}
                @Internal
                def workActionClass = TestWorkAction.class
                @Internal
                def additionalClasspath = project.layout.files()
                @Internal
                def foo = new Foo()
                @Internal
                def displayName = null
                @Internal

fun isolatedScriptsModelFor(project: ProjectInternal): IsolatedScriptsModel {
    // TODO:isolated compute own classpaths
    val additionalClassPath = ClassPath.EMPTY
    val additionalSourcePath = ClassPath.EMPTY
    val models = mutableListOf<IntermediateScriptModel>().apply {
        buildScriptModelFor(project, additionalClassPath, additionalSourcePath)?.let {
            add(it)
        }
        addAll(precompiledScriptModelsFor(project))
    }

                                    }
                                    if (config instanceof ClassLoaderWorkerSpec) {
                                        classpath.from(additionalClasspath)
                                    }
                                }).submit(workActionClass) {
                                    files = list.collect { it as String }

        given:
        def registry = new DefaultModuleRegistry(classLoaderFor([]), ClassPath.EMPTY, new GradleInstallation(distDir))

        expect:
        registry.additionalClassPath.empty
    }

    def "requires additional module classpath when no distribution available"() {
        given:
        def classesDir = tmpDir.createDir("out/production/someModule")

                def additionalForkOptions = {}
                @Internal
                def workActionClass = ${parallelWorkAction.name}.class
                @Internal
                def additionalClasspath = project.layout.files()

                @Inject
                WorkerExecutor getWorkerExecutor() {
                    throw new UnsupportedOperationException()
                }

                workActionClass = ${alternateExecution.name}.class
            }

            task runInWorker(type: WorkerTask) {
                isolationMode = $isolationMode
                additionalClasspath = files('${parameterJar.name}')
                foo = new FooWithUnserializableBar()
                finalizedBy runAgainInWorker
            }
        """

        when:
        fails("runInWorker")

Class <org.gradle.api.internal.tasks.testing.detection.ForkedTestClasspathFactory$AdditionalClasspath> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ForkedTestClasspathFactory.java:0)