failure.assertHasDescription("Execution failed for task ':compileGroovy'.");
    }

    @Test
    void failsCompilationWhenConfigScriptIsUpdated() {
        // compilation passes with a config script that does nothing
        executer.withTasks('compileGroovy').run().assertTasksExecutedInOrder(":compileJava",":compileGroovy")

        // make sure it fails if the config script applies type checking

#include "tensorflow/core/platform/status.h"

namespace tensorflow {

// Compiles a `function` to PjRtLoadedExecutable `executable` with `ctx`.
// The compilation result is output in `compilation_result`. The PJRT client
// used for compilation is output in `client`. The PJRT executable is output in
// `executable`.
Status CompileToPjRtLoadedExecutable(
    const OpKernelContext& ctx, const XlaPlatformInfo& platform_info,

 */

package org.gradle.api.tasks.compile

import org.gradle.test.fixtures.AbstractProjectBuilderSpec

class GroovyCompileTest extends AbstractProjectBuilderSpec {

    def "incremental compilation is disabled and incrementalAfterFailure is enabled by default"() {
        def groovyCompile = project.tasks.create("compileGroovy", GroovyCompile)

        expect:
        !groovyCompile.options.incremental

    // is not compatible with the configuration cache.
    FileCollection compileClasspath = configurations.compileClasspath
    from(compileClasspath)
    doFirst {
        println ">> Compilation deps: ${compileClasspath.files.name}"
    }
}

        Timer clock = Time.startTimer();
        ClassSetAnalysisData snapshot = classSetAnalyzer.analyzeOutputFolder(outputFolder);
        LOG.info("Class dependency analysis for incremental compilation took {}.", clock.getElapsed());
        return snapshot;
    }


    public ClassSetAnalysisData getClasspathSnapshot(final Iterable<File> entries) {
        if (classpathSnapshot == null) {

  // graph.
  bool unconditionally_use_set_output_shapes = false;
  // If set, use the value as the device type and mark the function graph for
  // XLA compilation.
  string xla_compile_device_type;
  // If true, enables moving ops to different devices or moving unsupported ops
  // out of a compilation cluster.
  bool enable_soft_placement = false;
  // If true, a function attribute, `tf._original_func_name`, will be set in

        succeeds "compile"
        def reversedAgainBytes = resultClass.bytes

        then:
        reversedAgainBytes == originalBytes
    }

    def "groovy and java source directory compilation order can be reversed (task configuration #configurationStyle)"() {
        given:
        file("src/main/groovy/Groovy.groovy") << "class Groovy { }"

        when:
        run ":compileJava"

        then:
        executedAndNotSkipped(":lib:compileScala")
        notExecuted(":lib:processResources", ":lib:jar")
    }

    def "scala and java source directory compilation order can be reversed (task configuration #configurationStyle)"() {
        given:
        file("src/main/scala/Scala.scala") << "class Scala { }"

                def main(args: Array[String]): Unit = {
                    print("Hello!")
                }
            }
        """.stripIndent()
        }
    }

    def "joint Java and Scala compilation can be cached"() {
        given:
        buildScript """
            plugins {
                id 'scala'
            }

            ${mavenCentralRepository()}

            dependencies {

    id('java')
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.apache.commons:commons-lang3:3.11'
}

// tag::copy[]
tasks.register('copyFiles', Copy) {
    println ">> Compilation deps: ${configurations.compileClasspath.files.name}"
    into(layout.buildDirectory.dir('output'))
    from(configurations.compileClasspath)
}