# class "feature"
    assert is_uploadfile_sequence_annotation(list[str] | list[UploadFile])


def test_serialize_sequence_value_with_optional_list():
    """Test that serialize_sequence_value handles optional lists correctly."""
    from fastapi._compat import v2

    field_info = FieldInfo(annotation=list[str] | None)
    field = v2.ModelField(name="items", field_info=field_info)

};

// Gets tensor from eager tensor handle.
const Tensor* GetTensorFromHandle(TFE_TensorHandle* h, TF_Status* status) {
  if (h == nullptr) {
    status->status = tensorflow::errors::InvalidArgument("Invalid handle");
    return nullptr;
  }
  tensorflow::TensorHandle* handle =
      tensorflow::TensorHandleFromInterface(tensorflow::unwrap(h));
  if (handle->Type() != TensorHandle::LOCAL) {

        this.flags = flags;
    }

    /**
     * Gets the context handle.
     *
     * @return the context handle
     */
    public byte[] getContextHandle() {
        return contextHandle;
    }

    /**
     * Sets the context handle.
     *
     * @param contextHandle the context handle
     */
    public void setContextHandle(byte[] contextHandle) {

	if err != nil {
		return errInvalidArgument
	}
	data := &syscall.Win32finddata{}
	handle, err := syscall.FindFirstFile(globAllP, data)
	if err != nil {
		if err = syscallErrToFileErr(dirPath, err); err == errFileNotFound {
			return nil
		}
		return err
	}
	defer syscall.FindClose(handle)

	for ; ; err = syscall.FindNextFile(handle, data) {
		if err != nil {
			if err == syscall.ERROR_NO_MORE_FILES {
				break
			}

import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.smb2.create.CreateContextResponse;

/**
 * SMB2 Durable Handle Response Create Context
 *
 * MS-SMB2 Section 2.2.14.2.3
 */
public class DurableHandleResponse implements CreateContextResponse {

    /**
     * Context name for durable handle response
     */
    public static final String CONTEXT_NAME = "DHnQ";

        this.registrationId = registrationId;
    }

    /**
     * Gets the context handle.
     *
     * @return the context handle
     */
    public byte[] getContextHandle() {
        return contextHandle;
    }

    /**
     * Sets the context handle.
     *
     * @param contextHandle the context handle
     */
    public void setContextHandle(byte[] contextHandle) {

                // Then
                assertEquals(4, bytesRead, "Failed at position " + pos);
            }
        }

        @Test
        @DisplayName("Should handle buffer with exact required size")
        void testReadBytesWireFormatExactBufferSize() throws SMBProtocolDecodingException {
            // Given
            byte[] buffer = new byte[4];

	fns       []func(*DB)
	callbacks []*callback
}

type callback struct {
	name      string
	before    string
	after     string
	remove    bool
	replace   bool
	match     func(*DB) bool
	handler   func(*DB)
	processor *processor
}

func (cs *callbacks) Create() *processor {
	return cs.processors["create"]
}

func (cs *callbacks) Query() *processor {
	return cs.processors["query"]
}

// Returns the DLDevice* for the given eager tensor handle.
//
// The caller takes ownership of the returned pointer and is responsible for
// deleting it.
TF_CAPI_EXPORT extern void* TFE_GetDLDevice(TFE_TensorHandle* h,
                                            TF_Status* status);

// Converts eager tensor handle to DLPack (DLManagedTensor*), and return the
// void* for further PyCapsule construction.

            assertEquals(0, response.getChunkBytesWritten());
            assertEquals(0, response.getTotalBytesWritten());
        }

        @Test
        @DisplayName("Should handle negative values as unsigned")
        void testDecodeNegativeValuesAsUnsigned() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[12];
            SMBUtil.writeInt4(-1, buffer, 0); // chunksWritten