import jcifs.internal.SmbBasicFileInfo;
import jcifs.internal.smb1.AndXServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Open AndX Response message.
 *
 * This response contains information about the opened file,
 * including file ID, attributes, size, and access permissions.
 */
public class SmbComOpenAndXResponse extends AndXServerMessageBlock implements SmbBasicFileInfo {

import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Read AndX request message.
 *
 * This command is used to read data from a file that has been
 * previously opened with an Open command.
 */
public class SmbComReadAndX extends AndXServerMessageBlock {

    private long offset;
    private int fid;
    int openTimeout;
    int maxCount, minCount, remaining;

    /**

        verify(mockHandle, never()).sendrecv(any(MsrpcSamrConnect2.class));
    }

    @Test
    void testClose_Successful() throws IOException {
        // Test case: close() when opened and successful MsrpcSamrCloseHandle
        String server = "testServer";
        int access = 123;

        // Setup for successful constructor

     * The caller is responsible for closing the returned stream.
     *
     * @return a new input stream positioned at the start of the content
     * @throws IOException if the stream cannot be created or opened
     */
    @Nonnull
    InputStream openStream() throws IOException;

    /**
     * Returns a human-readable description of where this source came from,
     * used primarily for error messages and debugging.

import jcifs.internal.smb2.rdma.RdmaChannelInfo;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Read request message.
 *
 * This command is used to read data from a file that has been
 * previously opened with a Create request.
 *
 * @author mbechler
 */
public class Smb2ReadRequest extends ServerMessageBlock2Request<Smb2ReadResponse> implements RequestWithFileId {

    /**

	}

	// Close underneath HTTP listener.
	srv.listenerMutex.Lock()
	err := srv.listener.Close()
	srv.listenerMutex.Unlock()
	if err != nil {
		return err
	}

	// Wait for opened connection to be closed up to Shutdown timeout.
	return nil
}

// UseIdleTimeout configure idle connection timeout
func (srv *Server) UseIdleTimeout(d time.Duration) *Server {
	srv.IdleTimeout = d
	return srv

 * writes to and reads from an existing pipe descriptor in one operation.
 * <li><code>CreateFile</code>, <code>ReadFile</code>,
 * <code>WriteFile</code>, and <code>CloseFile</code> A byte-type pipe can
 * be opened, written to, read from and closed using the standard Win32
 * file operations.
 * </ul>
 *
 * <p>
 * The jCIFS API maps all of these operations into the standard Java

import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;

/**
 * SMB2 Close request message. This command is used to close a file or directory
 * that was previously opened.
 *
 * @author mbechler
 *
 */
public class Smb2CloseRequest extends ServerMessageBlock2Request<Smb2CloseResponse> implements RequestWithFileId {

import jcifs.internal.smb2.ServerMessageBlock2Response;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;

/**
 * SMB2 Create response message. This response contains the file ID and attributes
 * of the created or opened file or directory.
 *
 * @author mbechler
 *
 */
public class Smb2CreateResponse extends ServerMessageBlock2Response implements SmbBasicFileInfo {

		if err != nil {
			rsc.Close()
			return err
		}

		s3Select.recordReader, err = csv.NewReader(s3Select.progressReader, &s3Select.Input.CSVArgs)
		if err != nil {
			// Close all reader resources opened so far.
			s3Select.progressReader.Close()

			var stErr bzip2.StructuralError
			if errors.As(err, &stErr) {
				return errInvalidCompression(err, s3Select.Input.CompressionType)
			}