TEST(DecodeShardingAttributeTest, CheckInvalidString) {
  xla::OpSharding sharding;
  EXPECT_TRUE(DecodeShardingAttribute("", sharding).succeeded());
  EXPECT_TRUE(DecodeShardingAttribute("manual", sharding).failed());
}

TEST(DecodeShardingAttributeTest, CheckManualShardString) {
  xla::OpSharding sharding;
  EXPECT_TRUE(DecodeShardingAttribute("{manual}", sharding).succeeded());
  EXPECT_TRUE(sharding.type() == sharding.MANUAL);

// or human readable.
mlir::LogicalResult DecodeShardingAttribute(const std::string& shard_str,
                                            xla::OpSharding& sharding,
                                            bool report_error = true);

// Encodes the sharding in human readable form.
mlir::LogicalResult DecodeShardingAttribute(mlir::Attribute shard_attr,

}

bool IsReplicatedSharding(const xla::OpSharding& sharding) {
  return sharding.type() == xla::OpSharding::REPLICATED ||
         IsOtherReplicatedSharding(sharding);
}

mlir::LogicalResult DecodeShardingAttribute(const std::string& shard_str,
                                            xla::OpSharding& sharding,
                                            bool report_error) {

  auto sharding_attr = mlir::dyn_cast<StringAttr>(attr);
  if (!sharding_attr)
    return op->emitOpError(
        llvm::formatv(kBadStringArrayElementMsg, name, index));
  if (tensorflow::DecodeShardingAttribute(sharding_attr, *sharding_ptr)
          .failed()) {
    return op->emitOpError(llvm::formatv(kBadArrayElementMsg, name, index,
                                         sharding_attr.getValue(),

    const OpShardingVariant& sharding_or_op) {
  xla::OpSharding sharding;
  const auto sharding_string = GetShardingStringFromVariant(sharding_or_op);
  if (!sharding_string) return std::nullopt;
  if (tensorflow::DecodeShardingAttribute(sharding_string->str(), sharding,
                                          false)
          .failed()) {
    return std::nullopt;
  }
  return sharding;
}

    const XlaShapeLayoutHelpers::ShapeDeterminationFns shape_determination_fns,
    xla::Shape* shape) {
  if (!sharding) return absl::OkStatus();

  xla::OpSharding op_sharding;
  if (tensorflow::DecodeShardingAttribute(sharding, op_sharding).failed()) {
    return errors::InvalidArgument("failed to parse sharding '",
                                   sharding.getValue().str(), "'");
  }

      // _XlaSharding attribute in TF is a serialized string of the OpSharding
      // proto, so convert to a text form here.
      ::xla::OpSharding sharding_proto;
      if (tensorflow::DecodeShardingAttribute(
              op.get_XlaSharding().value().str(), sharding_proto)
              .failed()) {
        return failure();
      }
      // Token is a control signal and not a real data, so arbitrarily assign