This sample shows how to configure a toolchain for a JVM project in Gradle.
Your project usually targets a specific java version.
Using toolchains, it is very simple to set the required java version while Gradle handles the setting up the tasks (e.g. compile and test) accordingly.

Concretely, we add a _convention plugin_ in `buildSrc` to share the setup between multiple subprojects:

====

  #   (5) injectionPath: the injection path to use for this tag webhook.
  #
  # Note that the revision tag "default" has additional semantic meaning as it
  # controls the revision that performs validation and the revision that handles
  # injection for default selectors ("istio-injection=enabled" and "sidecar.istio.io/inject").

#include "tensorflow/compiler/mlir/lite/experimental/tac/hardwares/target_hardware.h"
#include "tensorflow/compiler/mlir/lite/ir/tfl_ops.h"

namespace mlir {
namespace TFL {
namespace tac {
// Gpu hardware class which handles GPU capabilities in TFLite.
// This is used by TAC to get op supported/ op cost estimates on GPU.
class GpuHardware : public TargetHardware {
 public:
  static constexpr char kId[] = "GPU";

                Required.
              enum:
                - Delete
                - Retain
              type: string
            driver:
              description: driver is the name of the storage driver that handles this
                VolumeSnapshotClass. Required.
              type: string
            kind:
              description: 'Kind is a string value representing the REST resource this

	"k8s.io/apimachinery/pkg/runtime/serializer/recognizer"
	"k8s.io/apimachinery/pkg/util/framer"
	utilyaml "k8s.io/apimachinery/pkg/util/yaml"
	"k8s.io/klog/v2"
)

// NewSerializer creates a JSON serializer that handles encoding versioned objects into the proper JSON form. If typer
// is not nil, the object has the group, version, and kind fields set.
// Deprecated: use NewSerializerWithOptions instead.

import org.junit.Rule

class ScalaProjectIntegrationTest extends AbstractIntegrationSpec {
    @Rule
    ZincScalaCompileFixture zincScalaCompileFixture = new ZincScalaCompileFixture(executer, testDirectoryProvider)

    def "handles java source only"() {
        file("src/main/java/somepackage/SomeClass.java") << "public class SomeClass { }"
        buildFile << """
            apply plugin: 'scala'
        """
        settingsFile << """

// filteringContainer delegates all Handle(...) calls to Container.HandleWithFilter(...),
// so we can ensure restful.FilterFunctions are used for all handlers
type filteringContainer struct {
	*restful.Container

	registeredHandlePaths []string
}

func (a *filteringContainer) Handle(path string, handler http.Handler) {
	a.HandleWithFilter(path, handler)
	a.registeredHandlePaths = append(a.registeredHandlePaths, path)
}

package org.apache.maven.model.management;

import org.apache.maven.model.Model;
import org.apache.maven.model.building.ModelBuildingRequest;
import org.apache.maven.model.building.ModelProblemCollector;

/**
 * Handles injection of dependency management into the model.
 *
 */
public interface DependencyManagementInjector {

    /**
     * Merges default values from the dependency management section of the given model into itself.

    @get:HiddenInDeclarativeDsl
    var y: Int = 0
}


class HiddenInDslTest {
    val schema = schemaFromTypes(HasHiddenProperty::class, listOf(HasHiddenProperty::class))

    @Test
    fun `handles the hidden properties correctly`() {
        val aType = schema.dataClassesByFqName.getValue(DefaultFqName.parse(HasHiddenProperty::class.qualifiedName!!))
        assertTrue { aType.properties.single { it.name == "y" }.isHiddenInDsl }

 * under the License.
 */
package org.apache.maven.repository;

import java.util.List;

import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.settings.Mirror;

/**
 * Handles the selection of mirrors for repositories.
 *
 */
@Deprecated
public interface MirrorSelector {

    /**
     * Determines the mirror for the specified repository.
     *