return "compileScala.scalaCompileOptions.forkOptions"
    }

    @Override
    protected void setupProjectIn(TestFile projectDir) {
        def classes = new ScalaCompilationFixture(projectDir)
        classes.baseline()
        projectDir.file("build.gradle") << classes.buildScript()
    }

    @Override
    protected void prepareForRelocation(TestFile projectDir) {

     * Returns the classpath for the given classes.
     */
    List<File> originalClassPath(Class<?>... classes) {
        return classes.collect { ClasspathUtil.getClasspathForClass(it) }
    }


    /**
     * Makes a copy of the given classes and returns the classpath for these copies. Each class is added to its own classpath root.
     */
    List<File> isolatedClasses(Class<?>... classes) {
        return classes.collect {

            };
            var classes = [];
            if (dependency.alreadyRendered) {
                classes.push('alreadyRendered');
            }
            if (dependency.hasConflict) {
                classes.push('hasConflict');
            }
            if (!dependency.resolvable) {
                classes.push('unresolvable');
            }
            if (classes.length > 0) {

    }

    public void setClasses(Set<Path> classes) {
        this.classes = classes;
    }

    /**
     * A set of directories containing Jar files.
     */
    public Set<JarDirectory> getJarDirectories() {
        return jarDirectories;
    }

    public void setJarDirectories(Set<JarDirectory> jarDirectories) {
        this.jarDirectories = jarDirectories;
    }

    /**

		measurements. Compare only with other /cpu/classes metrics.

	/cpu/classes/gc/total:cpu-seconds
		Estimated total CPU time spent performing GC tasks. This metric
		is an overestimate, and not directly comparable to system CPU
		time measurements. Compare only with other /cpu/classes metrics.
		Sum of all metrics in /cpu/classes/gc.

	/cpu/classes/idle:cpu-seconds
		Estimated total available CPU time not spent executing

     *
     * @return source directories for the classes reported on
     * @see #getAllClassDirs()
     */
    @Internal
    public FileCollection getAllSourceDirs() {
        return sourceDirectories.plus(getAdditionalSourceDirs());
    }

    /**

        classes.put(fullyQualifiedClassName, metaData);
    }

    @Override
    public void each(Closure cl) {
        for (Map.Entry<String, T> entry : classes.entrySet()) {
            cl.call(new Object[]{entry.getKey(), entry.getValue()});
        }
    }

    public void each(Action<? super T> action) {
        for (T t : classes.values()) {
            action.execute(t);

                    public static void STATIC_IN_B() {}
                    public void foo() {}
                }
            '''
        )

        when:
        def clazzA = api.classes['com.acme.A']
        def clazzB = api.classes['com.acme.B']
        def extractedA = api.extractAndLoadApiClassFrom(clazzA)
        def extractedB = api.extractAndLoadApiClassFrom(clazzB)

        then:

        - org.gradle.jvm.version         = ${JavaVersion.current().majorVersion}
        - org.gradle.libraryelements     = classes
        - org.gradle.usage               = java-api
    Artifacts
        - $builtMainClassesPath (artifactType = java-classes-directory)

--------------------------------------------------
Variant archives
--------------------------------------------------
Configuration for archive artifacts.

package org.gradle.kotlin.dsl.fixtures

import kotlin.reflect.KClass


fun classEntriesFor(classes: Array<out KClass<*>>): Sequence<Pair<String, ByteArray>> =
    classes.asSequence().map { classEntryFor(it) }


fun classEntriesFor(vararg classes: Class<*>): Sequence<Pair<String, ByteArray>> =
    classes.asSequence().map { classEntryFor(it) }


fun classEntryFor(clazz: KClass<*>): Pair<String, ByteArray> =
    classEntryFor(clazz.java)