std::vector<std::string> GetAcceptedStableHLODialects() {
  // It returns the default list of accepted dialects.
  std::vector<std::string> accepted_dialects({"stablehlo", "builtin", "func"});
  return accepted_dialects;
}

std::vector<std::string> GetAcceptedTFLiteDialects() {
  // It returns the default list of accepted dialects.
  std::vector<std::string> accepted_dialects({"tfl", "builtin", "func"});
  return accepted_dialects;
}

// requantizing if a quantized output is required.
//
// The motivation behind these changes is for Dialects that assume only float
// or quantized computation, and do not support a mixture of these types on
// dense operations. Decomposition allows TFLite to be compiled to these
// dialects, such as TOSA.

#include <utility>

#include "mlir/Dialect/Quant/QuantTypes.h"  // from @llvm-project
#include "mlir/IR/BuiltinAttributes.h"  // from @llvm-project

  void SetUp() override {
    tsl::setenv("TF_QUANT_MLIR_DUMP_PREFIX", test_dir_.c_str(), 1);

    mlir::DialectRegistry dialects;
    dialects.insert<mlir::BuiltinDialect, mlir::func::FuncDialect,
                    mlir::stablehlo::StablehloDialect>();
    ctx_ = std::make_unique<mlir::MLIRContext>(dialects);
    ctx_->loadAllAvailableDialects();
  }

  void TearDown() override {
    // Delete files in the test directory.

// allowed, etc), and that the exit function F will be invoked under
// similar circumstances. That is the say, we are expecting that F
// uses normal / high-level Go code as opposed to one of the more
// restricted dialects used for the trickier parts of the runtime.
package exithook

import (
	"internal/runtime/atomic"
	_ "unsafe" // for linkname
)

// A Hook is a function to be run at program termination

  SmallVector<StringRef, 64> sorted_dialect(dialect_count_.keys());
  llvm::sort(sorted_op);
  llvm::sort(sorted_dialect);

  *os_ << " * Accepted dialects: ";
  int num_dialect = 0;
  // Print the accepted dialect list.
  for (const auto &dialect_name : accepted_dialects_) {
    *os_ << dialect_name;
    if (++num_dialect < accepted_dialects_.size()) {
      *os_ << ", ";
    }
  }

# limitations under the License.
# ==============================================================================

import tempfile
from mlir import ir
from mlir.dialects import stablehlo
import tensorflow as tf
from tensorflow.compiler.mlir.tensorflow_to_stablehlo.python import pywrap_tensorflow_to_stablehlo as tensorflow_to_stablehlo
from tensorflow.python.platform import test

namespace mlir {
class ShapedType;
}  // namespace mlir

namespace tensorflow {

using tsl::StatusOr;

// Add custom op prefix for TensorFlow dialects.
Status AddTensorFlowOpPrefix(std::string);

// Maps an MLIR op name in the TensorFlow dialect or the TensorFlow control
// dialect back into a TensorFlow valid op name.
absl::StatusOr<llvm::StringRef> GetTensorFlowOpName(llvm::StringRef);

# Description:
#   TensorFlow/TensorFlow Lite/XLA MLIR dialects and tools.

load(
    "//tensorflow:tensorflow.bzl",
    "tf_cc_binary",
    "tf_cc_test",
)
load("//tensorflow:tensorflow.default.bzl", "filegroup")
load("//tensorflow/core/platform:rules_cc.bzl", "cc_library")

package(
    # copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],
    default_visibility = ["//visibility:public"],
    licenses = ["notice"],

class ConvertTfQuantToMhloIntTest : public Test {
 protected:
  void SetUp() override {
    DialectRegistry dialects;
    dialects.insert<TF::TensorFlowDialect, func::FuncDialect, chlo::ChloDialect,
                    mhlo::MhloDialect, quant::QuantizationDialect>();
    ctx_ = std::make_unique<MLIRContext>(dialects);
    ctx_->loadAllAvailableDialects();

    // Create a CPU client with 1 device.
    TF_ASSERT_OK_AND_ASSIGN(

#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/SMLoc.h"
#include "llvm/Support/SourceMgr.h"
#include "mlir/Dialect/Arith/IR/Arith.h"  // from @llvm-project
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/Dialect/SCF/IR/SCF.h"  // from @llvm-project
#include "mlir/Dialect/Shape/IR/Shape.h"  // from @llvm-project
#include "mlir/IR/Builders.h"  // from @llvm-project