@Override
    public JavaExecSpec classpath(Object... paths) {
        this.classpath.from(paths);
        return this;
    }

    @Override
    public FileCollection getClasspath() {
        return classpath;
    }

    @Override
    public JavaExecSpec setClasspath(FileCollection classpath) {
        this.classpath = fileCollectionFactory.configurableFiles("classpath");
        this.classpath.setFrom(classpath);

            return modules;
        }

        @Override
        public ClassPath getAllRequiredModulesClasspath() {
            ClassPath classPath = ClassPath.EMPTY;
            for (Module module : getAllRequiredModules()) {
                classPath = classPath.plus(module.getClasspath());
            }
            return classPath;
        }

        private void collectRequiredModules(Set<Module> modules) {

        project.assertHasJavaFacetBuilders()

        // Classpath
        def classpath = classpath
        classpath.assertHasLibs('jstl-1.2.jar', 'guava-18.0.jar', 'javax.servlet-api-3.1.0.jar', 'junit-4.13.jar', 'hamcrest-core-1.3.jar')
        classpath.lib('guava-18.0.jar').assertIsDeployedTo("/WEB-INF/lib")
        classpath.lib('jstl-1.2.jar').assertIsExcludedFromDeployment()
        classpath.lib('junit-4.13.jar').assertIsExcludedFromDeployment()

        }
        when:
        def classpath = project.scalaRuntime.inferScalaClasspath([new File("other.jar"), new File("scala-library-2.10.1.jar")])
        then:
        assertHasCorrectDependencies(classpath, useZincVersion)
    }

    private void assertHasCorrectDependencies(classpath, zincVersion) {
        assert classpath instanceof LazilyInitializedFileCollection
        assert classpath.sourceCollections.size() == 1

           eclipse {
               classpath {
                   file {
                       whenMerged { classpath ->
                           classpath.entries.removeAll { it.kind == 'output' }
                           classpath.entries.add(new org.gradle.plugins.ide.eclipse.model.Output('$firstPath'))
                           classpath.entries.add(new org.gradle.plugins.ide.eclipse.model.Output('$secondPath'))

                    .fold(ClassPath.EMPTY) { classPath, module -> classPath + module.classpath }
                    .asFiles
            )
        }
}


internal
data class StandardKotlinBuildScriptTemplateModel(
    private val classPath: List<File>
) : KotlinBuildScriptTemplateModel, Serializable {

    override fun getClassPath() = classPath

        if (needJaxpImpl()) {
            classPath = addToClassPath(classPath, getClasspathForResource(getSystemClassLoader(), "META-INF/services/javax.xml.parsers.SAXParserFactory"));
            classPath = addToClassPath(classPath, getClasspathForClass("org.w3c.dom.ElementTraversal"));
        }

        return doCreateClassLoader(name, getIsolatedSystemClassLoader(), classPath);
    }

package org.gradle.kotlin.dsl.resolver

import com.nhaarman.mockito_kotlin.doReturn
import com.nhaarman.mockito_kotlin.mock
import org.gradle.internal.classpath.ClassPath
import org.gradle.kotlin.dsl.fixtures.FolderBasedTest
import org.gradle.kotlin.dsl.resolver.SourcePathProvider.sourcePathFor
import org.hamcrest.CoreMatchers.anyOf
import org.hamcrest.CoreMatchers.hasItems
import org.hamcrest.CoreMatchers.not
import org.hamcrest.MatcherAssert.assertThat

    }

    class ClassDetails {
        final String path
        final String className
        final String classpath

        ClassDetails(String path, String className, String classpath) {
            this.path = path
            this.className = className
            this.classpath = classpath
        }
    }

            programId: ProgramId,
            compilationClassPath: ClassPath,
            accessorsClassPath: ClassPath,
            initializer: (File) -> Unit
        ): File

        fun startCompilerOperation(
            description: String
        ): AutoCloseable

        fun compilationClassPathOf(
            classLoaderScope: ClassLoaderScope
        ): ClassPath

        /**