", dtype=", DataType_Name(DataType()),
                      ", type=", FullType().DebugString(), ")");
}

Status AbstractTensorHandle::TensorHandleStatus() const {
  // Tensor handles in current runtime don't carry error info and this method
  // should always return OK status.
  return absl::OkStatus();
}

		}
		handler.clusterNodeSelectors = make(map[string]string)
		handler.clusterNodeSelectors["clusterDefaultNodeSelector"] = test.defaultNodeSelector
		handler.clusterNodeSelectors[namespace.Name] = test.whitelist
		pod.Spec = api.PodSpec{NodeSelector: test.podNodeSelector}

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").

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.
     *

import org.gradle.launcher.daemon.protocol.Success;
import org.gradle.launcher.daemon.server.api.DaemonCommandAction;
import org.gradle.launcher.daemon.server.api.DaemonCommandExecution;

/**
 * Handles sending the result of the execution back to the client.
 *
 * Likely to be the first thing in the pipeline.
 */
public class ReturnResult implements DaemonCommandAction {