assertEquals(0, result);

        result = response.writeDataWireFormat(null, 0);
        assertEquals(0, result);
    }

    @Test
    @DisplayName("Test all read methods with null buffer")
    void testReadMethodsWithNullBuffer() {
        // Even with null buffer, methods should return 0 without throwing exception
        int result = response.readSetupWireFormat(null, 0, 0);

    /**
     * Unspecified session ID value
     */
    public static final long UNSPECIFIED_SESSIONID = 0xFFFFFFFFFFFFFFFFL;

    /**
     * SMB2 Channel constant for RDMA V1
     * Used in SMB2 READ and WRITE requests to indicate RDMA channel
     */
    public static final int SMB2_CHANNEL_RDMA_V1 = 0x00000001;

    /**
     * SMB2 Channel constant for RDMA V1 invalidate

        bufferIndex += 2;
        reserved1 = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        reserved2 = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // Read the transform (only expecting one)
        if (transformCount > 0) {
            rdmaTransformId = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;

        final int start = bufferIndex;

        final SmbInfoAllocation info = new SmbInfoAllocation();

        // Read total allocation units.
        info.alloc = readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // read caller available allocation units
        info.free = readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // skip actual free units

 * server. Rather than represent each with it's own <code>Exception</code>
 * class, this class represents all of them. For many of the popular
 * error codes, constants and text messages like "The device is not ready"
 * are provided.
 * <p>
 * The jCIFS client maps DOS error codes to NTSTATUS codes. This means that
 * the user may recieve a different error from a legacy server than that of

                        populate(r, tc);
                    }
                }
                result = this.table.get(name);
            }
        } catch (final IOException fnfe) {
            log.error("Could not read lmhosts " + tc.getConfig().getLmHostsFileName(), fnfe); //$NON-NLS-1$
        }
        return result;
    }

    void populate(final Reader r, final CIFSContext tc) throws IOException {
        String line;

        // File Size: 1024 bytes
        ServerMessageBlock.writeInt4(1024, buffer, 6);

        response.wordCount = 10; // Must be non-zero to read
        int bytesRead = response.readParameterWordsWireFormat(buffer, 0);

        // Should read 20 bytes as per implementation
        assertEquals(20, bytesRead);
        assertEquals(0x0010, response.getAttributes());

        when(resp.getOutputLength()).thenReturn(42);
        when(tree.send(any(Smb2IoctlRequest.class), any())).thenReturn(resp);

        byte[] out = new byte[10];
        int read = target.sendrecv(new byte[] { 9, 8, 7 }, 0, 3, out, 1024);
        assertEquals(42, read);

        // Verify we issued an SMB2 IOCTL
        ArgumentCaptor<Smb2IoctlRequest> captor = ArgumentCaptor.forClass(Smb2IoctlRequest.class);

import jcifs.internal.SMBProtocolDecodingException;

/**
 * Response for SMB1 TRANS_TRANSACT_NAMED_PIPE transaction.
 *
 * This response contains the data returned from the named pipe
 * after a transact operation (write then read) has been completed.
 */
public class TransTransactNamedPipeResponse extends SmbComTransactionResponse {

    private final byte[] outputBuffer;

    /**
     * Constructs a response for a named pipe transaction.

    /**
     * Connection establishment in progress
     */
    CONNECTING(1),

    /**
     * Authentication in progress
     */
    AUTHENTICATING(2),

    /**
     * Channel is established and ready for use
     */
    ESTABLISHED(3),

    /**
     * Channel binding in progress
     */
    BINDING(4),

    /**
     * Channel is actively transferring data
     */
    ACTIVE(5),

    /**