%4 = tfr.constant f32 -> !tfr.attr
    ```
  }];

  let arguments = (ins TFR_allowedConstValues:$value);

  let results = (outs TFR_AttrType:$out);

  let hasFolder = 1;

  let builders = [
    OpBuilder<(ins "Attribute":$value),
    [{
      auto* ctx = value.getContext();
      $_state.addAttribute("value", value);
      $_state.addTypes(TFRAttrType::get(ctx));
    }]>
  ];

		case runtime.GOOS == "linux" && runtime.GOARCH == "arm":
			t.Skip("too slow for arm builders")
		case runtime.GOOS == "linux" && (runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le"):
			t.Skip("too slow for mips64x builders")
		}
	}
	if testenv.Builder() == "darwin-amd64-10_14" {
		// TODO(#23011): When the 10.14 builders are gone, remove this skip.

      const auto& value = m[key];
      switch (value.GetType()) {
        case flexbuffers::FBT_INT: {
          auto attr = value.AsInt64();
          auto named_attr = builder->getNamedAttr(
              key, builder->getIntegerAttr(builder->getIntegerType(64), attr));
          attrs.push_back(named_attr);
          break;
        }
        case flexbuffers::FBT_VECTOR_BOOL: {
          llvm::SmallVector<bool> vec;

#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"  // from @llvm-project
#include "mlir/Dialect/Tensor/IR/Tensor.h"  // from @llvm-project
#include "mlir/IR/Builders.h"  // from @llvm-project
#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
#include "mlir/IR/BuiltinTypes.h"  // from @llvm-project
#include "mlir/IR/Diagnostics.h"  // from @llvm-project

          if (attr.getName() != kCalledIndexAttrName) {
            new_config.push_back(attr);
          }
        }

        Builder builder(op.getContext());
        // Sets the `called_index` attribute to the TF function's name.
        new_config.push_back(builder.getNamedAttr(kCalledFuncAttrName,
                                                  function_list[called_index]));

  tensor.add_float_val(42.0);

  mlir::MLIRContext context;
  mlir::Builder builder(&context);
  TF_ASSERT_OK_AND_ASSIGN(mlir::ElementsAttr attribute,
                          ConvertTensorProto(tensor, &builder));
  EXPECT_THAT(
      attribute,
      AllOf(Eq(mlir::DenseElementsAttr::get(
                mlir::RankedTensorType::get({1ULL << 35}, builder.getF32Type()),
                42.0f)),

    Type expected_type = std::get<1>(ArgAndType);
    if (arg.getType() != expected_type) {
      arg = builder.create<CastOp>(loc, expected_type, arg,
                                   /*Truncate=*/builder.getBoolAttr(false));
    }
    casted_args.push_back(arg);
  }
  auto call = builder.create<func::CallOp>(loc, func, casted_args);

  auto results = call.getResults();
  auto block_args = entry->getArguments();

        }
    }

    open fun extraCustomRuntimeClasspathProviders(): Array<Constructor<RuntimeClasspathProvider>> = emptyArray()

    override fun configureTest(builder: TestConfigurationBuilder) {
        super.configureTest(builder)
        with(builder) {
            useDirectives(Directives)
            useConfigurators(::CompilerFacilityEnvironmentConfigurator)
            defaultDirectives {

  func::FuncOp func = getOperation();
  OpBuilder builder(func);

  func.walk([&](Operation *op) {
    if (op->hasTrait<OpTrait::IsTerminator>()) return;
    auto op_name = op_to_name_(op);

    // Check the named info collection first.
    auto it = name_to_info_.find(op_name);
    if (it != name_to_info_.end()) {
      ImportAsStatsOps(builder, op, it->second.first, it->second.second);
      return;
    }

    }

    OpBuilder builder(loc.getContext());
    for (const auto& name_and_value : node_def.attr()) {
      const std::string& attr_name = name_and_value.first;
      const tensorflow::AttrValue& attr_value = name_and_value.second;
      absl::StatusOr<Attribute> mlir_attr =
          tensorflow::ConvertAttributeValue(attr_value, &builder);
      if (!mlir_attr.ok()) {