namespace mlir::quant {

// Converts arguments of the @main function that are bound to
// `tf_saved_model::AssetOp`s into regular tensor args. Returns `AsestFileDef`s
// that associates the arg with the asset.
//
// In detail, this function performs the following:
// * Replaces "tf_saved_model.bound_input" attributes to
//   "tf_saved_model.index_path", if the bound input is attached to the
//   `tf_saved_model::AssetOp`.

# CHECK-SAME: bad_consumers
# CHECK-SAME: min_consumer
# CHECK-SAME: producer

# CHECK: tf_saved_model.session_initializer
# CHECK-SAME: initializers = [@[[restore:.*]]]

# CHECK: "tf_saved_model.asset"()
# CHECK-SAME: <{filename = [[filename:.*]], sym_name = "[[sym_name:.*]]"}> : () -> ()

# CHECK:      func @[[restore]](
# CHECK-SAME:   [[variable_path:%.*]]: tensor<!tf_type.string> {tf_saved_model.bound_input = @[[sym_name]]}

        encodePreservingSharedIdentityOf(value) {
            write(value.componentId)
            write(value.attributes)
            writeCollection(value.capabilities.asSet())
        }
    }

    override suspend fun ReadContext.decode(): ComponentVariantIdentifier {
        return decodePreservingSharedIdentity {
            val componentId = readNonNull<ComponentIdentifier>()

  ASSERT_EQ(bound_inputs.size(), 2);

  auto global_tensor =
      llvm::cast<mlir::tf_saved_model::GlobalTensorOp>(bound_inputs[0]);
  auto asset = llvm::cast<mlir::tf_saved_model::AssetOp>(bound_inputs[1]);

  EXPECT_EQ(global_tensor.getSymName(), "y");
  EXPECT_EQ(asset.getSymName(), "z");
}

TEST(SavedModelTest, CompileToBEF) {
  std::string saved_model_mlir_path = tensorflow::GetDataDependencyFilepath(

    @Override
    public String getDisplayName() {
        return displayName.getDisplayName();
    }

    @Override
    public List<Capability> getCapabilities() {
        return ImmutableList.copyOf(capabilities.asSet());
    }

    @Override
    public Optional<ResolvedVariantResult> getExternalVariant() {
        return Optional.ofNullable(externalVariant);
    }

    @Override
    public boolean equals(Object o) {

  "tf_saved_model.session_initializer"() {initializers = [@NoOp]} : () -> ()
  "tf_saved_model.asset"() {filename = "assets/mydata.txt", sym_name = "__tf_saved_model_asset0_mydata.txt"} : () -> ()
// Session initializer ops and asset ops untouched.
// CHECK: "tf_saved_model.session_initializer"() <{initializers = [@NoOp]}> : () -> ()
// CHECK: "tf_saved_model.asset"() <{filename = "assets/mydata.txt", sym_name = "__tf_saved_model_asset0_mydata.txt"}> : () -> ()

            sb.append("   - Variant ").append(candidate.getDisplayName()).append(" provides ");
            sb.append(CapabilitiesDescriber.describeCapabilities(failure.getTargetComponentId(), candidate.getCandidateCapabilities().asSet())).append("\n");
        }
        return sb.toString();
    }

    private final Set<ImmutableCapability> descriptors;

    public DefaultMutableCapabilitiesMetadata(ImmutableCapabilities capabilities) {
        this.descriptors = new LinkedHashSet<>(capabilities.asSet());
    }

    @Override
    public void addCapability(String group, String name, String version) {
        for (Capability descriptor : descriptors) {

    override suspend fun WriteContext.encode(value: AbstractTransformedArtifactSet.CalculateArtifacts) {
        write(value.ownerId)
        write(value.targetVariantAttributes)
        writeCollection(value.capabilities.asSet())
        val files = mutableListOf<Artifact>()
        value.delegate.visitExternalArtifacts { files.add(Artifact(file, artifactName.classifier)) }
        write(files)
        val steps = unpackTransformSteps(value.steps)

        } else {
            return new DefaultImmutableCapability(capability.getGroup(), capability.getName(), capability.getVersion());
        }
    }

    public ImmutableSet<ImmutableCapability> asSet() {
        return capabilities;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {