then:
        model.classpath.downloadJavadoc

        when: "configure classpath file"
        model.classpath.file({ fcm -> fcm.xmlTransformer } as Action<XmlFileContentMerger>)

        then:
        1 * xmlMerger.getXmlTransformer()

        when: "configure classpath XML"
        model.classpath.file.withXml(xmlAction)

        then:
        1 * xmlTransformer.addAction(xmlAction)
    }

           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   containers 'containerPath'
                   file {
                       whenMerged { classpath ->
                           classpath.entries.find { it.path == 'containerPath' }.entryAttributes.customKey = 'customValue'
                       }
                   }
               }
           }
        """

package org.gradle.kotlin.dsl.accessors

import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath

import org.gradle.kotlin.dsl.fixtures.TestWithTempFiles
import org.gradle.kotlin.dsl.fixtures.classEntriesFor
import org.gradle.kotlin.dsl.support.bytecode.InternalName
import org.gradle.kotlin.dsl.support.bytecode.beginClass
import org.gradle.kotlin.dsl.support.bytecode.endClass

    }

    @Override
    protected ClassLoader doCreateClassLoader(String name, ClassLoader parent, ClassPath classPath) {
        ClassLoader classLoader = super.doCreateClassLoader(name, parent, classPath);
        hashCodes.put(classLoader, calculateClassLoaderHash(classPath));
        return classLoader;
    }

    @Override

     * @param dstDir where the compiler will output the class files
     * @param classes the classes to compile
     * @param classPath the classpath to use for compilation
     */
    public static void compile(File srcDir, File dstDir, List<ClassSource> classes, ClassPath classPath) throws GeneratedClassCompilationException {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        if (compiler == null) {

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.support

import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath

import java.io.File


fun ClassPath.filter(predicate: (File) -> Boolean): ClassPath =

    fun projectAccessorsClassPath(scriptTarget: ExtensionAware, classPath: ClassPath): AccessorsClassPath =
        scriptTarget.getOrCreateProperty("gradleKotlinDsl.accessorsClassPath") {
            buildAccessorsClassPathFor(scriptTarget, classPath)
                ?: AccessorsClassPath.empty
        }


    private
    fun buildAccessorsClassPathFor(scriptTarget: Any, classPath: ClassPath): AccessorsClassPath? =

// tag::module-before-merged[]
// tag::module-when-merged[]

eclipse.classpath.file {
// end::module-when-merged[]
    beforeMerged(Action<Classpath> {
        entries.removeAll { entry -> entry.kind == "lib" || entry.kind == "var" }
    })
// end::module-before-merged[]
// tag::module-when-merged[]
    whenMerged(Action<Classpath> { ->
        entries.filter { entry -> entry.kind == "lib" }

    }

    String wrapClassDirs(String classpath) {
        if (language == CompiledLanguage.GROOVY) {
            if (useJar) {
                return "api.jar, ${classpath}, main"
            } else {
                // api/build/classes/java/main and api/build/classes/groovy/main
                // impl/build/classes/java/main
                return "main, main, ${classpath}, main"
            }
        } else {

        res = transform.transform(graph, ArtifactScopeEnum.compile, false);

        assertNotNull(res, "null classpath container after compile transform");
        assertNotNull(res.getClasspath(), "null classpath after compile transform");
        assertEquals(3, res.getClasspath().size(), "compile classpath should have 3 entries");
    }

    // ------------------------------------------------------------------------------------------