#include "tensorflow/core/lib/core/status.h"

namespace tensorflow {
namespace tf2xla {
namespace v1 {

// Run all the passes involved in transforming the graph before execution so
// that it is suitable for targeting devices when called via the TF1 Session
// API.
// These transformations take as input a Tensorflow Graph as an MLIR Module
// and transforms the module in place to cluster the given ops for compilation

import org.gradle.plugin.use.PluginDependenciesSpec
import org.gradle.plugin.use.PluginDependency
import org.gradle.plugin.use.PluginDependencySpec


/**
 * Legacy script template definition for precompiled Kotlin scripts targeting [Project] instances.
 */
@Deprecated("Kept for compatibility with precompiled script plugins published with Gradle versions prior to 6.0")
open class PrecompiledProjectScript(
    override val delegate: Project

		// library path work. If this is what's necessary to run gfortran, we
		// should reconcile the logic here and in cmd/go.. Maybe this should
		// become a cmd/go script test to share that logic.

		// Add -m32 if we're targeting 386, in case this is a cross-compile.
		if runtime.GOARCH == "386" {
			fcExtra = append(fcExtra, "-m32")
		}

		// Find libgfortran. If the FORTRAN compiler isn't bundled

// and the generated metadata object file.
struct CodegenOpts {
  // The name of the generated C++ class, wrapping the generated function.
  string class_name;

  // Target triple for the architecture we're targeting.
  string target_triple;

  // Namespaces specifies a list of C++ namespaces to add to the generated
  // header.  If empty, all symbols will be in the global namespace.
  std::vector<string> namespaces;

#include "tensorflow/core/lib/core/status.h"

namespace tensorflow {
namespace tf2xla {
namespace v2 {

// Run all the passes involved in transforming the graph before execution so
// that it is suitable for targeting devices when called with the TF 2 Function
// API. Users that need clustering with the Session API should use the v1 Bridge
// API. These transformations take as input a Tensorflow Graph as an MLIR Module

                    }
                }
            }
        }

        where:
        conf << ['runtime', 'test']
    }

    def "explicit configuration selection in ivy modules is NOT supported if targeting a #target module"() {
        given:
        setupRepositories([target, 'ivy'])
        repository('ivy') {
            "org:ivy:1.0" {
                withModule(IvyModule) {

     * on higher versions.
     *
     * @since 5.3
     */
    public abstract void disableAutoTargetJvm();

    /**
     * Tells if automatic JVM targeting is enabled. When disabled, Gradle
     * will not automatically try to get dependencies corresponding to the
     * same (or compatible) level as the target compatibility of this module.
     *
     * @since 5.3
     */

test.integration.%.kube.presubmit:
	@make test.integration.$*.kube

# Run all tests
.PHONY: test.integration.kube
test.integration.kube: test.integration.kube.presubmit
	@:

# Presubmit integration tests targeting Kubernetes environment. Really used for postsubmit on different k8s versions.
.PHONY: test.integration.kube.presubmit
test.integration.kube.presubmit: | $(JUNIT_REPORT) check-go-tag
	$(call run-test,./tests/integration/...)

  quantization_config.mutable_static_range_ptq_preset()
      ->set_enable_per_channel_quantized_weight(
          quantization_options.enable_per_channel_quantization());
  // When targeting server TPUs quantized types should be unpacked into
  // integer ops.
  quantization_config.mutable_pipeline_config()->set_unpack_quantized_types(
      true);
  *quantization_config.mutable_debugger_config() =

  separated by slashes (eg: "plan9/386/sse2", "plan9/amd64/"). This is
  needed in the rare case that you need to do a codegen test affected
  by a specific operating system; by default, tests are compiled only
  targeting linux.


- Remarks, and Caveats

-- Write small test functions

As a general guideline, test functions should be small, to avoid
possible interactions between unrelated lines of code that may be