RET

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

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

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

void TFE_DeleteContextOptions(TFE_ContextOptions* options) { delete options; }

TFE_Context* TFE_NewContext(const TFE_ContextOptions* opts, TF_Status* status) {
  if (opts->use_tfrt) {
    status->status = tensorflow::errors::Unimplemented("TFRT is not supported");
    return nullptr;
  }
  std::vector<std::unique_ptr<tensorflow::Device>> devices;
  status->status = tensorflow::DeviceFactory::AddDevices(

	metav1.TypeMeta
	nested runtime.Object
}

func (w *wrappedParam) MarshalJSON() ([]byte, error) {
	return nil, errors.New("MarshalJSON unimplemented for wrappedParam")
}

func (w *wrappedParam) UnmarshalJSON(data []byte) error {
	return errors.New("UnmarshalJSON unimplemented for wrappedParam")
}

func (w *wrappedParam) ToUnstructured() interface{} {

TEXT runtime·access(SB),$0-20
	MOVV	R0, 2(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
	MOVV	R0, 2(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
	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go

                                         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());

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.