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);
    }

        }
        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

        // 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,

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

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

        fun startCompilerOperation(
            description: String
        ): AutoCloseable

        fun compilationClassPathOf(
            classLoaderScope: ClassLoaderScope
        ): ClassPath

        /**

 */
package org.gradle.api.internal.classpath;

import org.gradle.internal.classpath.ClassPath;

import java.util.Set;

/**
 * Meta-data about a dynamically loadable module.
 */
public interface Module {
    /**
     * Returns the classpath for the module implementation. This is the classpath of the module itself. Does not include any dependencies.
     */
    ClassPath getImplementationClasspath();

    /**

    }

    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
        }
    }

        assertThat(
            classPath.collect { it.name } as List<String>,
            hasItems(fileNameSetOf(files))
        )
    }

    protected static void assertExcludes(List<File> classPath, File... files) {
        assertThat(
            classPath.collect { it.name } as List<String>,
            not(hasItems(fileNameSetOf(files)))
        )
    }