constexpr int64_t kDefaultCompilationThreshold = 2;

  // Should allow compilation since this is the first execution.
  profiler->RegisterExecution(function);
  EXPECT_TRUE(
      profiler->ShouldCompileCluster(function, DeviceCompileMode::kLazy, 0));

  // Shouldn't allow compilation until compilation has been requested at least
  // kDefaultCompilationThreshold times.
  profiler->RegisterExecution(function);

            }
        """
    }

    def "when doing a join compilation java problems are formatted the same as a standalone compication"() {
        given:
        file("src/main/groovy/JavaThing.java") << """\
            public class JavaThing {
                public void badMethod() {
                    // The following line will cause a compilation error
                    return "Hello, World!"
                }

        private final ProblemGroup java = new DefaultProblemGroup("java", "Java compilation", this);
        private final ProblemGroup groovy = new DefaultProblemGroup("groovy", "Groovy compilation", this);
        public ProblemGroup groovyDsl = new DefaultProblemGroup("groovy-dsl", "Groovy DSL script compilation", this);

        private DefaultCompilationProblemGroup(String id, String displayName) {

import java.io.File

/**
 * In-memory compilation result returned from [KaCompilerFacility].
 *
 * Compilation fails if there are critical errors reported either on the frontend or on the backend side.
 * Keep in mind that [KaCompilationResult] is a part of Analysis API, so it should only be used inside an analysis block.
 */
public sealed class KaCompilationResult {
    /**
     * Successful compilation result.
     *

     * but for the CLI compiler where incremental compilation after failure is not supported.
     */
    def "detects deletion of a source base class that leads to compilation failure"() {
        def a = source "class A {}"
        source "class B extends A {}"

        'compilation:java:initialization-failed' : 'Java compilation initialization error',
        'compilation:java:java-compilation-error' : 'Java compilation error',
        'compilation:java:java-compilation-failed' : 'Java compilation error',
        'compilation:java:java-compilation-warning' : 'Java compilation warning',

                    return new File[0];
                }
            }
        """

        when:
        Compilation compilation = compile(givenFirstSource, givenSecondSource)

        then:
        assertThat(compilation).succeededWithoutWarnings()
        assertThat(compilation)

 *     <li><code>implementation</code> dependencies are used at compilation and runtime.</li>
 *     <li><code>compileOnly</code> dependencies are used only at compilation and are not available at runtime.</li>
 *     <li><code>runtimeOnly</code> dependencies are not available at compilation and are used only at runtime.</li>
 *     <li><code>annotationProcessor</code> dependencies are used only at compilation for the annotation processor classpath</li>
 * </ul>
 *

}

dependencies {
    implementation("org.codehaus.groovy:groovy-all:2.4.15")
    testImplementation("junit:junit:4.13")
}

// tag::groovy-cross-compilation[]
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(7)
    }
}

dependencies {
    implementation("commons-collections:commons-collections:3.2.2")
    testImplementation("junit:junit:4.13")
}

// tag::force-compilation[]
tasks.withType<ScalaCompile>().configureEach {
    scalaCompileOptions.apply {
        isForce = true
    }
}