/**
 * A factory for caches that contain some calculated value for a particular file. Maintains a cross-build in-memory and persistent cache of computed values. The value for a given file is updated when the content of the file changes.
 */
public interface FileContentCacheFactory {
    /**
     * Creates or locates a cache. The contents of the cache are reused across builds, where possible.
     *

[[part:releases]]
== **RELEASES**

include::installation.adoc[leveloffset=+2]
include::compatibility.adoc[leveloffset=+2]
include::feature_lifecycle.adoc[leveloffset=+2]

[[part:running_builds]]
== **RUNNING GRADLE BUILDS**

== CORE CONCEPTS

include::gradle_basics.adoc[leveloffset=+2]
include::gradle_wrapper_basics.adoc[leveloffset=+2]
include::command_line_interface_basics.adoc[leveloffset=+2]

description = "Provides plugins used to create a Gradle plugin with Groovy or Kotlin DSL within build-logic builds"

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
        vendor = JvmVendorSpec.ADOPTIUM
    }
}

dependencies {
    compileOnly("com.gradle:develocity-gradle-plugin:3.17.4")

    api(platform(project(":build-platform")))

    implementation(project(":basics"))

        //this rule is just here to ensure backwards compatibility for builds that create publications with model rules
    }

    @Mutate
    void tasksDependOnProjectPublicationRegistry(ModelMap<Task> tasks, PublishingExtension extension) {
        //this rule is just here to ensure backwards compatibility for builds that create publications with model rules
    }

### JVM platform

This is a platform that builds on the core and software platforms to add support for developing software that runs on the JVM.
This includes software that is implemented using Java, Kotlin or some other JVM language.

This platform provides specific support for Java, Groovy and Scala, and includes the foojay toolchain plugin.

### Extensibility platform

This means that you can use the same API to work with builds that use different versions of Gradle, including versions that are newer or older than the version of the Tooling API that you are using.
The Tooling API is Gradle wrapper aware and, by default, uses the same Gradle version as that used by the wrapper-powered build.

Some features that the Tooling API provides:

  *  `build/run.sh make`: Build just linux binaries in the container.  Pass options and packages as necessary.
  *  `build/run.sh make cross`: Build all binaries for all platforms. To build only a specific platform, add `KUBE_BUILD_PLATFORMS=<os>/<arch>`
  *  `build/run.sh make kubectl KUBE_BUILD_PLATFORMS=darwin/amd64`: Build the specific binary for the specific platform (`kubectl` and `darwin/amd64` respectively in this example)

- Evaluates the settings file to determine which projects (and included builds) make up the build.
- Creates a link:{groovyDslPath}/org.gradle.api.Project.html[`Project`] instance for every project.
Phase 2. Configuration::
- Evaluates the build scripts, `build.gradle(.kts)`, of every project participating in the build.
- Creates a task graph for requested tasks.
Phase 3. Execution::

  }

  val summary = summaryListener.summary
  summary.printTo(PrintWriter(System.out))

  exitProcess(if (summary.testsFailedCount != 0L) -1 else 0)
}

/**
 * Builds the Junit Test Engine for the native image.
 */
fun buildTestEngine(): TestEngine = JupiterTestEngine()

/**
 * Returns a fixed set of test classes from testlist.txt, skipping any not found in the

	// Compile a small package with and without the concurrent
	// backend, then check to make sure that the resulting archives
	// are identical.  Note: this uses "go tool compile" instead of
	// "go build" since the latter will generate different build IDs
	// if it sees different command line flags.
	scenarios := []struct {
		tag     string
		args    string
		libpath string
	}{
		{tag: "serial", args: "-c=1"},
		{tag: "concurrent", args: "-c=2"}}