package elf

import (
	"io"
	"path"
	"reflect"
	"testing"
)

// TODO: remove duplicate code
func TestSymbols(t *testing.T) {
	do := func(file string, ts []Symbol, getfunc func(*File) ([]Symbol, error)) {
		var f *File
		var err error
		if path.Ext(file) == ".gz" {
			var r io.ReaderAt
			if r, err = decompress(file); err == nil {
				f, err = NewFile(r)
			}
		} else {

                }

                public SubDependencies getSub() {
                    return sub;
                }

                @Configuring
                public void sub(Action<? super SubDependencies> configure) {
                    configure.execute(getSub());
                }
            }
        """

	msg.Iovlen = 1
	if n, err = sendmsg(fd, &msg, flags); err != nil {
		return 0, err
	}
	if len(oob) > 0 && len(p) == 0 {
		n = 0
	}
	return n, nil
}

func (sa *RawSockaddrUnix) getLen() (int, error) {
	// Some versions of AIX have a bug in getsockname (see IV78655).
	// We can't rely on sa.Len being set correctly.
	n := SizeofSockaddrUnix - 3 // subtract leading Family, Len, terminating NUL.

  assert(metadata_str && "Missing compilation metadata");
  tensorflow::tpu::TPUCompileMetadataProto metadata;
  metadata.ParseFromString(std::string(metadata_str.getValue()));
  int64_t num_replicas = replicate.getN();
  // Find the formattable operands of `execute`, which must be mirrored
  // variables (arguments of `replicate`), and must be pass-throughs from while
  // operands.

* Prüfen und lesen Sie den Code, fragen Sie sich, ob er Sinn macht, **führen Sie ihn lokal aus** und testen Sie, ob er das Problem tatsächlich löst.

* Schreiben Sie dann einen **Kommentar** und berichten, dass Sie das getan haben. So weiß ich, dass Sie ihn wirklich überprüft haben.

!!! info
    Leider kann ich PRs, nur weil sie von Mehreren gutgeheißen wurden, nicht einfach vertrauen.

    auto min_max_type = GetUniformQuantizedType(
        op, op.getMin().getType(), op.getScales(), op.getZeroPoints(),
        /*expressed_type=*/rewriter.getF32Type(), op.getQuantizationMinVal(),
        op.getQuantizationMaxVal(), op.getQuantizationAxis(), rewriter);
    if (failed(min_max_type)) {
      return failure();
    }
    auto min_or = CreateConstantOrConvertOp(op, adaptor.getMin(), *min_max_type,

	require.NoError(t, c.rotateLogs(ctx))

	// Start a routine that can monitor the queue and shutdown the queue to trigger the retrun from the processQueueItems
	// Keeping the monitor duration smaller in order to keep the unwanted delay in the test to a minimal.
	go func() {
		pollTimeoutCtx, cancel := context.WithTimeout(ctx, 10*time.Second)

      auto it = buffer_to_size->find(addn.getOperand(0));
      if (it != buffer_to_size->end()) {
        addn.getSum().setType(
            mlir::cast<TensorType>(addn.getOperand(0).getType()));
        auto size = it->getSecond();
        (*buffer_to_size)[addn.getSum()] = size;
      }
    } else if (auto zeros = llvm::dyn_cast<TF::ZerosLikeOp>(&op)) {
      if (buffer_to_size->count(zeros.getX()) > 0) {

      continue;

    const auto inputs = partitioned_input.getInputs();
    const bool packed_input = partitioned_input.getIsPacked();
    int num_cores_per_replica = partitioned_input.getN();
    if (num_cores_per_replica_attr) {
      num_cores_per_replica = num_cores_per_replica_attr.getInt();
    } else if (packed_input) {
      return partitioned_input->emitOpError()

  if (!status->status.ok()) return;
  auto run_metadata = context->ExportRunMetadata();
  status->status = MessageToBuffer(*run_metadata, buf);
}

namespace {
TFE_Op* GetFunc(TFE_Context* ctx, const tensorflow::NameAttrList& func,
                TF_Status* status) {
  TFE_Op* func_op = TFE_NewOp(ctx, func.name().data(), status);
  for (const auto& attr : func.attr()) {