// locks we have already acquired will be released when the VariableInfo
      // objects are destroyed.
      // TODO(b/128495870) Add support for passing aliased resource variables.
      return errors::Unimplemented("Duplicate variable passed to XLA cluster");
    }
    if (variables[i]->read_only()) {
      VLOG(4) << "Acquiring reader lock for variable "
              << reinterpret_cast<void*>(variable);

                                         DefaultXlaOptions().device_type);

  MockXlaCompilerClient mock_client;
  EXPECT_CALL(mock_client, SerializeExecutable(_))
      .WillOnce(Return(errors::Unimplemented("Unimplemented.")));
  EXPECT_CALL(mock_client, BuildSerializedExecutable(_, _))
      .WillOnce(Return(serialized_xla_executable_));

  TF_ASSERT_OK_AND_ASSIGN(auto executable, BuildSampleExecutable());

		0, rsan, rsan, &lrsa, &llen, &rrsa, &rlen)
	lsa, _ := lrsa.Sockaddr()
	rsa, _ := rrsa.Sockaddr()

	netfd.setAddr(netfd.addrFunc()(lsa), netfd.addrFunc()(rsa))
	return netfd, nil
}

// Unimplemented functions.

func (fd *netFD) dup() (*os.File, error) {
	// TODO: Implement this, perhaps using internal/poll.DupCloseOnExec.
	return nil, syscall.EWINDOWS

TEXT runtime·access(SB),$0-20
	MOVD	R0, 0(R0) // unimplemented, only needed for android; declared in stubs_linux.go
	MOVW	R0, ret+16(FP) // for vet
	RET

TEXT runtime·connect(SB),$0-28
	MOVD	R0, 0(R0) // unimplemented, only needed for android; declared in stubs_linux.go
	MOVW	R0, ret+24(FP) // for vet
	RET

TEXT runtime·socket(SB),$0-20
	MOVD	R0, 0(R0) // unimplemented, only needed for android; declared in stubs_linux.go

                                  uint64 size) override {
    // TODO(annarev): figure out if we should support memzero/memset
    // functionality by allocating on host and then copying to device.
    return tsl::errors::Unimplemented(
        "SynchronousMemZero is not supported by pluggable device.");
  }
  absl::Status SynchronousMemcpy(DeviceMemoryBase* gpu_dst,
                                 const void* host_src, uint64 size) override {

}

func (testEncodableDuplicateTag) DeepCopyObject() runtime.Object {
	panic("unimplemented")
}

type testEncodableTagMatchesUntaggedName struct {
	metav1.TypeMeta `json:",inline"`

	A       int
	TaggedA int `json:"A"`
}

func (testEncodableTagMatchesUntaggedName) DeepCopyObject() runtime.Object {
	panic("unimplemented")
}

type staticTextMarshaler int

    case DT_UINT64:
      ConvertUIntElementsAttr(dense_attr, output->mutable_uint64_val(),
                              output->mutable_tensor_content());
      break;
    default:
      return errors::Unimplemented(absl::StrCat("Unimplemented data type ",
                                                DataTypeString(output_dtype)));
  }
  return absl::OkStatus();
}

		stream, err := pluginInstance.NodeListAndWatchResources(ctx, new(drapb.NodeListAndWatchResourcesRequest))
		if err != nil {
			switch {
			case status.Convert(err).Code() == codes.Unimplemented:
				// The plugin simply doesn't provide node resources.
				active.cancel(errors.New("plugin does not support node resource reporting"))
			default:
				// This is a problem, report it and retry.

  };
  StreamExecutor* executor = GetExecutor(0);
  TF_ASSERT_OK_AND_ASSIGN(auto stream, executor->CreateStream());
  std::function<absl::Status()> callback = []() -> absl::Status {
    return tsl::errors::Unimplemented("Unimplemented");
  };
  ASSERT_FALSE(stream->DoHostCallbackWithStatus(callback).ok());
}

TEST_F(StreamExecutorTest, DeviceDescription) {
  static const char* hardware_name = "TestName";

    // Skip if it has default value (TODO(unda, b/249345399): add our custom
    // values)
    if (api_def_attr.has_default_value()) continue;
    // TODO(unda, b/253432797): handle unimplemented input attribute types
    if (unhandled_attr_types.find(attr.type()) != unhandled_attr_types.end()) {
      std::cout << "NOT fuzzing: " << op_info.graph_op_def.name()