) {
        this.applicationClasspath = applicationClasspath;
        this.applicationModulepath = applicationModulepath;
        this.implementationClasspath = implementationClasspath;
        this.implementationModulepath = implementationModulepath;
    }

    public ImmutableList<File> getApplicationClasspath() {
        return applicationClasspath;
    }

            List<TestFrameworkDistributionModule> applicationClasspath,
            List<TestFrameworkDistributionModule> applicationModulepath,
            List<TestFrameworkDistributionModule> implementationClasspath,
            List<TestFrameworkDistributionModule> implementationModulepath
        ) {
            this.applicationClasspath = applicationClasspath;
            this.applicationModulepath = applicationModulepath;

            if (!useOptionsFile) {
                // Serialize the application classpath, this is consumed by BootstrapSecurityManager
                outstr.writeInt(applicationClasspath.size());
                for (File file : applicationClasspath) {
                    outstr.writeUTF(file.getAbsolutePath());
                }
                // Serialize the actual security manager type, this is consumed by BootstrapSecurityManager

        when:
        def framework = newFramework(false, [], [], [], [])
        def classpath = underTest.create([new File("cls.jar")], [new File("mod.jar")], framework, false)

        then:
        classpath.applicationClasspath == [new File("cls.jar")]
        classpath.applicationModulepath == [new File("mod.jar")]
        classpath.implementationClasspath.size() == NUM_INTERNAL_JARS + NUM_EXTERNAL_JARS

            builder.applicationClasspath(classPathRegistry.getClassPath("MINIMUM_WORKER_RUNTIME").getAsFiles());
            builder.useApplicationClassloaderOnly();
            builder.applicationClasspath(toFiles(flatClassLoaderStructure.getSpec()));
        } else {
            builder.applicationClasspath(classPathRegistry.getClassPath("CORE_WORKER_RUNTIME").getAsFiles());
        }

    }

    @Override
    public WorkerProcessBuilder applicationClasspath(Iterable<File> files) {
        for (File file : files) {
            if (file == null) {
                throw new IllegalArgumentException("Illegal null value provided in this collection: " + files);
            }
            if (isEntryValid(file)) {
                applicationClasspath.add(file);
            }
        }
        return this;

        workerProcessBuilder.setImplementationClasspath(implementationClasspath.getAsURLs());
    }

    @Override
    public WorkerProcessSettings applicationClasspath(Iterable<File> files) {
        workerProcessBuilder.applicationClasspath(files);
        return this;
    }

    @Override
    public WorkerProcessSettings applicationModulePath(Iterable<File> files) {

        builder.setBaseName("Gradle ANTLR Worker");

        if (antlrClasspath != null) {
            builder.applicationClasspath(antlrClasspath);
        }
        builder.sharedPackages("antlr", "org.antlr");
        JavaExecHandleBuilder javaCommand = builder.getJavaCommand();
        javaCommand.setWorkingDir(workingDir);

        return this;
    }

    @Override
    public String getBaseName() {
        return builder.getBaseName();
    }

    @Override
    public WorkerProcessSettings applicationClasspath(Iterable<File> files) {
        builder.applicationClasspath(files);
        return this;
    }

    @Override
    public Set<File> getApplicationClasspath() {
        return builder.getApplicationClasspath();
    }

    @Override

 */
public interface WorkerProcessSettings {
    WorkerProcessSettings setBaseName(String baseName);

    String getBaseName();

    WorkerProcessSettings applicationClasspath(Iterable<File> files);

    Set<File> getApplicationClasspath();

    WorkerProcessSettings applicationModulePath(Iterable<File> files);

    Set<File> getApplicationModulePath();