}
                }
            }
        } catch (IOException e) {
            throw new PACDecodingException("Malformed PAC", e);
        }

        if (this.serverSignature == null || this.kdcSignature == null || this.logonInfo == null) {
            throw new PACDecodingException("Missing required buffers");
        }

                    return buf;
                }, StringIndexOutOfBoundsException.class));
    }

    @ParameterizedTest(name = "{0}")
    @MethodSource("invalidBuffers")
    @DisplayName("Invalid buffers throw appropriate exceptions")
    void invalidInputsThrow(String name, Object bufferSupplierOrBytes, Class<? extends Throwable> expected) {
        // Arrange
        byte[] buf;

        spyTarget.send(b, 1, 2);
        verify(out).writeDirect(b, 1, 2, 1);
    }

    @Test
    @DisplayName("sendrecv with null buffers throws relevant exceptions")
    void testSendRecvInvalidInputs() throws CIFSException {
        // Null out buffer for SMB2 path -> expect NPE when building request
        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);

    /**
     * Creates a security descriptor by decoding from a byte buffer.
     *
     * @param buffer the byte buffer containing the security descriptor data
     * @param bufferIndex the starting offset in the buffer
     * @param len the length of data to decode
     * @throws IOException if an I/O error occurs during decoding
     */
    public SecurityDescriptor(final byte[] buffer, final int bufferIndex, final int len) throws IOException {

                bufferIndex += 2;
                pathOffset = readInt2(buffer, bufferIndex);
                bufferIndex += 2;
                altPathOffset = readInt2(buffer, bufferIndex);
                bufferIndex += 2;
                nodeOffset = readInt2(buffer, bufferIndex);
                bufferIndex += 2;

                path = readString(buffer, start + pathOffset, len, (flags2 & FLAGS2_UNICODE) != 0);

    /**
     * Creates a security descriptor by decoding from a byte buffer.
     *
     * @param buffer the byte buffer containing the security descriptor data
     * @param bufferIndex the starting offset in the buffer
     * @param len the length of data to decode
     * @throws IOException if an I/O error occurs during decoding
     */
    public SecurityDescriptor(final byte[] buffer, final int bufferIndex, final int len) throws IOException {

     *
     * @param buffer memory buffer to register
     * @param access access permissions
     */
    public RdmaMemoryRegion(ByteBuffer buffer, EnumSet<RdmaAccess> access) {
        this.buffer = buffer;
        this.accessFlags = access;
        this.localKey = generateLocalKey();
        this.remoteKey = generateRemoteKey();
        this.address = getBufferAddress(buffer);
        this.valid = true;
    }

            this.dataWireFormatReturn = value;
        }

        void setSetupBuffer(byte[] buffer) {
            this.setupBuffer = buffer;
        }

        void setParametersBuffer(byte[] buffer) {
            this.parametersBuffer = buffer;
        }

        void setDataBuffer(byte[] buffer) {
            this.dataBuffer = buffer;
        }
    }

    @BeforeEach
    void setUp() {

    }

    @Override
    public int decode(final byte[] buffer, final int bufferIndex) throws SMBProtocolDecodingException {
        return decode(buffer, bufferIndex, false);
    }

    /**
     * Decodes the SMB2 message from the buffer.
     *
     * @param buffer the buffer containing the message
     * @param bufferIndex the starting position in the buffer
     * @param compound whether this is part of a compound chain

        setPrivateField(cmd, "maxReferralLevel", 0x12AB);
        byte[] buffer = new byte[100];
        int len = cmd.writeParametersWireFormat(buffer, 0);
        assertTrue(len >= 2);
        // writeInt2 writes in little-endian format (LSB first)
        assertEquals(0xAB, buffer[0] & 0xFF);
        assertEquals(0x12, buffer[1] & 0xFF);
        // Check that the path is written after the referral level