==============================================================================*/

#include "tensorflow/compiler/mlir/tf2xla/api/v2/tf_dialect_to_executor.h"

#include <memory>
#include <string>

#include "absl/log/log.h"
#include "absl/status/status.h"
#include "llvm/ADT/StringRef.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/IR/BuiltinOps.h"  // from @llvm-project

    TF_DeleteStatus(status);
    return ok;
  };
  StreamExecutor* executor = GetExecutor(0);
  TF_ASSERT_OK_AND_ASSIGN(auto stream, executor->CreateStream());
  std::function<absl::Status()> callback = []() -> absl::Status {
    return absl::OkStatus();
  };
  TF_ASSERT_OK(stream->DoHostCallbackWithStatus(callback));
}

TEST_F(StreamExecutorTest, HostCallbackError) {

        "@com_google_absl//absl/strings",
    ],
)

cc_library(
    name = "error_collector_inst",
    srcs = ["error_collector_inst.cc"],
    hdrs = ["error_collector_inst.h"],
    deps = [
        ":error_collector",
        ":types_util",
        "//tensorflow/lite/python/metrics:converter_error_data_proto_cc",
        "@com_google_absl//absl/strings",
        "@llvm-project//mlir:IR",

#include <algorithm>
#include <array>
#include <iterator>
#include <memory>
#include <string>
#include <utility>

#include "absl/algorithm/container.h"
#include "absl/cleanup/cleanup.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h"

        "//tensorflow/core:lib",
        "//tensorflow/core/common_runtime/device:device_utils",
        "//tensorflow/core/platform:strcat",
        "@com_google_absl//absl/functional:any_invocable",
        "@com_google_absl//absl/status",
        "@com_google_absl//absl/strings:str_format",
        "@local_tsl//tsl/platform:status",
        "@local_xla//xla/stream_executor",
        "@local_xla//xla/stream_executor:executor_cache",

#include "tensorflow/compiler/mlir/lite/utils/string_utils.h"

#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <vector>

#include "absl/status/status.h"

namespace mlir::TFL {

absl::Status MiniDynamicBuffer::AddString(const char* str, size_t len) {
  // If `data_.size() + len` is greater than `SIZE_MAX` then the left hand side

func (x *Rat) GobEncode() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	buf := make([]byte, 1+4+(len(x.a.abs)+len(x.b.abs))*_S) // extra bytes for version and sign bit (1), and numerator length (4)
	i := x.b.abs.bytes(buf)
	j := x.a.abs.bytes(buf[:i])
	n := i - j
	if int(uint32(n)) != n {
		// this should never happen
		return nil, errors.New("Rat.GobEncode: numerator too large")
	}

    done(status);
    return;
  }
  if (auto st = stream_->BlockHostUntilDone(); !st.ok()) {
    done_event_.SetError(absl::InternalError(absl::StrFormat(
        "failed to synchronize send operation with a stream: %s",
        st.ToString())));
    return;
  }

  done_event_.SetStateConcrete();
  done(absl::OkStatus());
}

namespace tensorflow {
namespace generator {
namespace cpp {

string OpArgumentView::Declaration() const {
  return absl::Substitute("$0 $1", type_name_, variable_name_);
}

string OpArgumentView::Initializer() const {
  if (default_value_.empty()) {
    return "";
  }
  return absl::Substitute(" = $0", default_value_);
}

bool OpArgumentView::HasDefaultValue() const { return !default_value_.empty(); }

#include "tsl/platform/errors.h"

namespace tensorflow {
namespace {
constexpr absl::string_view kGroupSizeAttrName =
    "tf2xla.collective_info.group_size";
constexpr absl::string_view kGroupKeyAttrName =
    "tf2xla.collective_info.group_key";

// Extracts shape from XlaArgument as TensorShape. If shape is a xla::Shape,
// that is converted to a TensorShape.
absl::StatusOr<TensorShape> GetTensorShapeFromXlaArgument(
    const XlaArgument& arg) {