}
        """

        when:
        withInstallations(earlierJdk).run(":compileJava", "--info")

        then:
        executedAndNotSkipped(":compileJava")
        outputContains("Compiling with toolchain '${earlierJdk.javaHome.absolutePath}'")
        outputContains("sourceCompatibility: '${earlierJdk.javaVersion}'")
        outputContains("targetCompatibility: '${earlierJdk.javaVersion}'")

/**
 * Base class for tests that invoke external process with the dynamic Groovy code.
 * There are many different ways to run a process in Groovy, and all are producing different byte code.
 * The class supports compiling Groovy code in both indy and old-school CallSite modes.
 */
abstract class AbstractProcessInstrumentationInDynamicGroovyIntegrationTest extends AbstractProcessInstrumentationIntegrationTest implements DynamicGroovyPluginMixin {

    // Number of times the cluster has been (re-)compiled.
    int64_t compile_count = 0;

    // The number of times this cluster has been executed.
    int64_t execution_count = 0;

    // Cumulative time spent compiling the cluster.
    int64_t cumulative_compile_time_us = 0;

    // True if we have decided that this cluster is too dynamic (i.e. its shapes
    // change too frequently) to profitably JIT compile.  Once a cluster is

        }

    private
    fun assertCompilations(stage: CachedScript.CompilationStage, count: Int) =
        result.assertOccurrenceCountOf("compiling", stage, count)
}


fun cachedInitializationFile(file: File, hasInitscriptBlock: Boolean = false, hasBody: Boolean = false) =
    CachedScript.WholeFile(

// See the License for the specific language governing permissions and
// limitations under the License.

[[task_basics]]
= Task Basics

A task represents some *independent unit of work* that a build performs, such as compiling classes, creating a JAR, generating Javadoc, or publishing archives to a repository.

image::gradle-basic-5.png[]

You'll discover that Gradle has a rich API for working with dependencies — one that takes time to master, but is straightforward to use for common scenarios.


[[sec:compile]]
== Compiling your code

Compiling both your production and test code can be trivially easy if you follow the conventions:

 1. Put your production source code under the _src/main/java_ directory
 2. Put your test source code under _src/test/java_

	PkgMap map[int]int

	// Set to true if we discover a package mapping glitch.
	hardCodedListNeedsUpdating bool
}

// AddMeta is invoked during package "init" functions by the
// compiler when compiling for coverage instrumentation; here 'p' is a
// meta-data blob of length 'dlen' for the package in question, 'hash'
// is a compiler-computed md5.sum for the blob, 'pkpath' is the

project\u001B[m\u001B[14D\u001B[1B\u001B[2A\u001B[1m<\u001B[0;32;1;0;39;1m-------------> 0% CONFIGURING [1s]\u001B[m\u001B[35D\u001B[1B\u001B[1m> root project > Compiling /Users/ghale/repos/gradle/build/tmp/teŝt files/RichConsoleBasicGroupedTaskLoggingFunctionalTest/long_running_task_o...ter_delay/w661/build.gradle into local compilation cache > Compiling build file '/Users/ghale/repos/gradle/build/tmp/test files/RichConsoleBasicGroupedTaskLoggingFunctionalTest/long_running_task_o...ter_delay/w661/build.gradle'...

    std::vector<std::unique_ptr<mlir::Pass>>& custom_legalization_passes,
    xla::CompileOnlyClient* client, XlaCompilationResult* compilation_result) {
  LOG_FIRST_N(INFO, 1) << "Compiling MLIR computation to XLA HLO using the "
                          "Combined MLIR Tf2Xla Bridge.";

  absl::StatusOr<std::string> mlir_compilation =
      internal::CompileFromMlirToXlaHlo(

                println(diagnostic.source)
                println(diagnostic.getMessage(null))
            }
            throw new RuntimeException('Failure compiling test fixture')
        }
    }

    private static class FileManager
        extends ForwardingJavaFileManager<StandardJavaFileManager> {

        private List<ClassFile> output = new ArrayList<>()