// Setup for SamrSamEntry decode chain
            mockDeferredBuffer.deferred = mockDeferredBuffer;
            when(mockDeferredBuffer.dec_ndr_short()).thenReturn(0, 0, 0);

            // When: Decoding output
            message.decode_out(mockNdrBuffer);

            // Then: Should decode all output parameters
            verify(samArray).decode(mockNdrBuffer);

        assertEquals(0x1111, response.getSecurityMode(), "First decode security mode");
        assertEquals(0x0210, response.getDialect(), "First decode dialect");

        // Second decode - should overwrite values
        byte[] buffer2 = new byte[50];
        SMBUtil.writeInt4(0x22222222, buffer2, 0);
        SMBUtil.writeInt2(0x2222, buffer2, 20);
        SMBUtil.writeInt2(0x0311, buffer2, 22);

        SMBUtil.writeInt4(messageLength, buffer, bufferIndex + 12);
        System.arraycopy(testData, 0, buffer, bufferIndex + 16, testData.length);

        // Decode
        int bytesDecoded = response.decode(buffer, bufferIndex, buffer.length);

        // Verify results
        assertEquals(namedPipeState, response.getNamedPipeState());
        assertEquals(readDataAvailable, response.getReadDataAvailable());

            // When: Decoding the value
            ndrShort.decode(mockBuffer);

            // Then: Should set the negative value directly (no masking on decode)
            verify(mockBuffer).dec_ndr_short();
            assertEquals(negativeValue, ndrShort.value);
        }

        @Test
        @DisplayName("Should decode large value correctly")
        void testDecodeLargeValue() throws NdrException {

            assertEquals(0, buffer.getNumReferrals());
            assertEquals(0, buffer.getTflags());
        }
    }

    @Nested
    @DisplayName("Decode Tests")
    class DecodeTests {

        @Test
        @DisplayName("Should decode buffer with no referrals")
        void testDecodeNoReferrals() {
            // Prepare test data: pathConsumed=0, numReferrals=0, tflags=0

        // Decode
        smbInfoAllocation.decode(buffer, 0, buffer.length);

        // Verify - with sectPerAlloc = 1, capacity = alloc * bytesPerSect
        assertEquals(alloc * bytesPerSect, smbInfoAllocation.getCapacity());
        assertEquals(free * bytesPerSect, smbInfoAllocation.getFree());
    }

    @Test
    @DisplayName("Test decode with large bytes per sector")

    }

    /**
     * Test case for the decode method.
     * Verifies that the decode method of a concrete implementation is called
     * and interacts with the NdrBuffer as expected.
     * @throws NdrException if decoding fails.
     */
    @Test
    void testDecode() throws NdrException {
        // When
        ndrObject.decode(mockBuffer);

        // Then

                    this.info = new DfsEnumStruct();
                }
                this.info.decode(_src);

            }
            final int _totalentriesp = _src.dec_ndr_long();
            if (_totalentriesp != 0) {
                this.totalentries.decode(_src);

            }
            this.retval = _src.dec_ndr_long();
        }
    }

            assertEquals(FileSystemInformation.FS_SIZE_INFO, fileFsSizeInfo.getFileSystemInformationClass());
        }
    }

    @Nested
    @DisplayName("Decode Method Tests")
    class DecodeMethodTests {

        @Test
        @DisplayName("Should decode buffer with typical values correctly")
        void shouldDecodeBufferWithTypicalValues() throws SMBProtocolDecodingException {

    /**
     * Creates a Kerberos AP request from a token.
     *
     * @param token the Kerberos AP-REQ token
     * @param keys the Kerberos keys for decryption
     * @throws PACDecodingException if the token cannot be decoded
     */
    public KerberosApRequest(byte[] token, KerberosKey[] keys) throws PACDecodingException {
        this(parseSequence(token), keys);
    }