"testdata/strided_slice.mlir",
    ],
    deps = [
        ":error_collector",
        ":error_collector_inst",
        ":types_util",
        "//tensorflow/compiler/mlir/tensorflow",
        "//tensorflow/core:test",
        "//tensorflow/core/platform:errors",
        "//tensorflow/core/platform:resource_loader",
        "//tensorflow/lite/python/metrics:converter_error_data_proto_cc",
        "@com_google_absl//absl/status:statusor",

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func f[P any](a, _ P) {
	var x int
	// TODO(gri) these error messages, while correct, could be better
	f(a, x /* ERROR "type int of x does not match inferred type P for P" */)
	f(x, a /* ERROR "type P of a does not match inferred type int for P" */)
}

func g[P any](a, b P) {
	g(a, b)
	g(&a, &b)

// RUN: tf-opt %s -split-input-file -verify-diagnostics -tf-launch-to-device-attribute=legacy-graph-export=true | FileCheck %s


// Tests single TensorFlow op is hoisted out and has the correct device assigned
// by parent `tf_device.launch`.
// CHECK-LABEL: func @single_op_launch
func.func @single_op_launch() {
  tf_executor.graph {
    %0:5 = tf_executor.island {
      %a = "tf.opA"() : () -> tensor<i1>
      %launch:2 = "tf_device.launch"() ({

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cgosotest

/*
// intentionally write the same LDFLAGS differently
// to test correct handling of LDFLAGS.
#cgo linux LDFLAGS: -L. -lcgosotest
#cgo dragonfly LDFLAGS: -L. -l cgosotest
#cgo freebsd LDFLAGS: -L. -l cgosotest
#cgo openbsd LDFLAGS: -L. -l cgosotest
#cgo solaris LDFLAGS: -L. -lcgosotest

        when:
        strictParser.parseNotation(notation)

        then:
        InvalidUserDataException ex = thrown()
        ex.message == "Invalid format for capability: '$notation'. The correct notation is a 3-part group:name:version notation, e.g: 'org.group:capability:1.0'"

        where:
        notation << [
                "foo:bar",
                "foo:bar:",
                "foo::1.0",

     *
     * @param referrerProject The project that is going to use the Gradle instance
     * @param gradle The Gradle instance that the project has direct access to.
     * @return A Gradle instance that implements correct cross-project model access.
     */
    GradleInternal gradleInstanceForProject(ProjectInternal referrerProject, GradleInternal gradle);

    /**

	string(config.LeastAllocated),
	string(config.MostAllocated),
	string(config.RequestedToCapacityRatio),
)

// ValidateDefaultPreemptionArgs validates that DefaultPreemptionArgs are correct.
func ValidateDefaultPreemptionArgs(path *field.Path, args *config.DefaultPreemptionArgs) error {
	var allErrs field.ErrorList
	percentagePath := path.Child("minCandidateNodesPercentage")

  let summary = "Convert fallback tensor to corert tensorhandle";

  let description = [{
    Convert the fallback tensor to corert tensorhandle.

    args: a list of fallback tensors.
    device: the name of the tensorflow device that is associated with the
      input fallback tensors.

    results: the converted corert tensorhandles.
  }];

  let arguments = (ins

        }
    }

    @ToBeFixedForConfigurationCache(because = "build listener")
    def 'projectsLoaded listeners are attributed to the correct registrant'() {
        given:
        def addGradleListeners = { String source ->
            """
                gradle.projectsLoaded({
                    println "gradle.projectsLoaded(Action) from $source"

        val generatedTopLevelClassifiers = declarationGenerators
            .asSequence()
            .flatMap {
                // FIXME this function should be called only once during plugin's lifetime, so this usage is not really correct (2)
                it.getTopLevelClassIds()
            }
            .filter { it.packageFqName == packageFqName }
            .map { it.shortClassName }

        return generatedTopLevelClassifiers.toSet()
    }