// RUN: tf-opt -tfe-legalize-tfg %s | FileCheck %s

// CHECK: module attributes {tf.versions = {bad_consumers = [], min_consumer = 12 : i32, producer = 919 : i32}}
module  {
  // CHECK: tf_executor.graph
  tfg.graph #tf_type.version<producer = 919, min_consumer = 12> {

    /**
     * Adds an action to be executed when a value from a pending element is concretely added.
     * The provided action is only called when a pending value is realized and the value is not
     * already present in the concrete values of this source.
     */
    void onPendingAdded(Action<T> action);

    boolean isEmpty();

    int size();

    void clear();

    def "can execute query and mutating methods #method.key from withType.all"() {
        buildFile << """
            testContainer.withType(testContainer.type).all {
                if (it.name == "realized") {
                    ${method.value}
                }
            }
        """

        expect:
        succeeds "help"

        where:
        method << getQueryMethods() + getMutationMethods()

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

namespace mlir {
namespace TFL {
namespace {
#define GEN_PASS_DEF_LEGALIZEWHILEPASS
#include "tensorflow/compiler/mlir/lite/transforms/passes.h.inc"

// Legalize TF While to TFL While with calls to the original functions from the
// cond and body regions.
struct LegalizeWhilePass
    : public impl::LegalizeWhilePassBase<LegalizeWhilePass> {

 * limitations under the License.
 */

package org.gradle.api.internal.tasks;

import org.gradle.internal.operations.BuildOperationType;

/**
 * Represents a creation request for a task. Actual task may be realized later.
 *
 * @since 4.9
 */
public final class RealizeTaskBuildOperationType implements BuildOperationType<RealizeTaskBuildOperationType.Details, RealizeTaskBuildOperationType.Result> {

    public interface Details {

    def "can execute query and mutating methods #method.key from all"() {
        buildFile << """
            testContainer.all {
                if (it.name == "realized") {
                    ${method.value}
                }
            }
        """

        expect:
        succeeds "help"

        where:
        method << getQueryMethods() + getMutationMethods()

    def "can execute query and mutation methods #method.key from getByName"() {
        buildFile << """
            testContainer.getByName("realized") {
                ${method.value}
            }
        """

        expect:
        succeeds "help"

        where:
        method << getQueryMethods() + getMutationMethods()
    }
}

      /*allow_mutable_tensors=*/true));

  // Generic MLIR optimization passes.
  pm.addPass(mlir::createCanonicalizerPass());
  pm.addPass(mlir::TF::CreateTFShapeInferencePass());

  // Legalizes TF UniformQuantized types into MHLO.
  pm.addNestedPass<func::FuncOp>(
      mlir::quant::stablehlo::CreateConvertTFQuantOpsToMHLOPass());
  pm.addPass(mlir::createCanonicalizerPass());

  // TF -> StableHLO legalization.

    const ::stablehlo::quantization::DebuggerConfig& debugger_config);

// Deserializes StableHLO functions serialized and embedded in XlaCallModuleOps.
void AddXlaCallModuleOpDeserializationPasses(OpPassManager& pm);

// Legalizes shape/tensor/arith dialect ops to StableHLO for handling dynamic
// shapes, by going through a round-trip to MHLO.
void AddShapeLegalizationPasses(OpPassManager& pm);

  CellReader<int64_t> counts(kBridgeStatusCounter);

  auto result = CompileMlirModule(kBadMlirModuleStr);

  ASSERT_FALSE(result.ok());
  // Never failed to legalize because it was never attempted
  EXPECT_EQ(legalize_failure_count.Read("tf.DoesntExist", "Unknown"), 0);
  EXPECT_THAT(result,
              IncrementedOrFiltered(counts.Delta(kMlirCombinedMlirSuccess), 1));