@Rule public final ZincScalaCompileFixture zincScalaCompileFixture = new ZincScalaCompileFixture(executer, temporaryFolder)

    @Requires(IntegTestPreconditions.BestJreAvailable)
    def "scala java cross compilation works when JAVA_HOME is set to JRE"() {
        given:
        def jreJavaHome = AvailableJavaHomes.bestJre
        file("src/main/scala/org/test/JavaClazz.java") << """
                    package org.test;

        when:
        succeeds ':compileJava' // the internal class can be accessed

        then:
        javaClassFile('consumer/MainModule.class').exists()
    }

    def "fails module compilation for missing requires"() {
        given:
        publishJavaModule('moda')
        consumingModuleInfo()
        consumingModuleClass('moda.ModaClass')

        when:
        fails ':compileJava'

            class Hello {
                public static void main(String... args) {
                    println "Hello!"
                }
            }
        """.stripIndent()
        }
    }

    def "compilation is cached if location of the Groovy library is different"() {
        given:
        populateCache()

        executer.requireOwnGradleUserHomeDir() // dependency will be downloaded into a different directory

            return new PreviousCompilationData.Serializer(interner).read(encoder);
        } catch (Exception e) {
            throw new IllegalStateException("Could not read previous compilation result.", e);
        }
    }

    public void writePreviousCompilationData(PreviousCompilationData data, File target) {
        try (KryoBackedEncoder encoder = new KryoBackedEncoder(new FileOutputStream(target))) {

import java.util.regex.Pattern

/**
 * Removes Scala Zinc compilation time logging from the build-init Scala samples output.
 * Also removes the potential warning around using `-target` instead of `-release`.
 * */
class ZincScalaCompilerOutputNormalizer implements OutputNormalizer {

    private static final PATTERN = Pattern.compile(
        "(Scala Compiler interface compilation took ([0-9]+ hrs )?([0-9]+ mins )?[0-9.]+ secs\n\n)" +

import javax.annotation.Nullable;
import java.io.File;
import java.util.List;
import java.util.Set;

/**
 * Represents the compilation details for a binary.
 *
 * @since 4.10
 */
public interface CompilationDetails {
    /**

>> Compilation deps: [commons-lang3-3.11.jar]...

those provided by package "net/rpc".

The implementation compiles a custom codec for each data type in the stream
and is most efficient when a single Encoder is used to transmit a stream of
values, amortizing the cost of compilation.
-- text --
Package gob manages streams
of gobs - binary values
exchanged between an Encoder
(transmitter) and a Decoder
(receiver). A typical use
is transporting arguments
and results of remote

    def "including over 250 projects is not possible via varargs in Groovy 3"() {
        createProjectDirectories(254, includeFunction)
        // Groovy doesn't even support >=255 args at compilation, so to trigger the right error
        // 254 projects must be used instead.
        settingsFile << """
            rootProject.name = 'root'

import javax.tools.DiagnosticListener;
import javax.tools.JavaCompiler;
import java.io.Closeable;
import java.nio.charset.Charset;
import java.util.Locale;

/**
 * Cleans up resources (e.g. file handles) after compilation has finished.
 */
class ResourceCleaningCompilationTask implements JavaCompiler.CompilationTask {
    private final JavaCompiler.CompilationTask delegate;
    private final Closeable fileManager;