List<AvPair> pairs = AvPairs.decode(fullData);

        assertNotNull(pairs, "Decoded pairs should not be null");
        assertEquals(1, pairs.size(), "Should have decoded one pair");

        AvPair pair = pairs.get(0);
        assertEquals(AvPair.MsvAvFlags, pair.getType(), "Pair type should be MsvAvFlags");
        assertTrue(pair instanceof AvFlags, "Should be decoded as AvFlags");

        // Decode
        FileRenameInformation2 decoded = new FileRenameInformation2();
        int bytesRead = decoded.decode(buffer, 0, bytesWritten);

        // Verify round trip
        assertEquals(bytesWritten, bytesRead);
        assertEquals(original.size(), decoded.size());
        assertEquals(original.getFileInformationLevel(), decoded.getFileInformationLevel());
    }

    @Test

        // Decode from buffer
        NdrBuffer decodeBuffer = new NdrBuffer(buffer, 0);
        lsarpc.LsarTranslatedName decodedName = new lsarpc.LsarTranslatedName();
        decodedName.decode(decodeBuffer);

        // Verify the decoded data matches
        assertEquals(translatedName.sid_type, decodedName.sid_type);

            assertEquals(8, encoded);

            // Decode into new instance
            FileEndOfFileInformation decoded = new FileEndOfFileInformation();
            int decodedBytes = decoded.decode(buffer, 0, buffer.length);

            assertEquals(8, decodedBytes);

            // Verify values match
            assertEquals(original.toString(), decoded.toString());
        }
    }

    @Test

        // create a new empty range and decode
        LockingAndXRange decoded = new LockingAndXRange(false);
        int decodedSize = decoded.decode(dst, 0, dst.length);
        assertEquals(10, decodedSize, "Decode should return size 10");
        assertEquals(99, decoded.getPid());
        assertEquals(123456L, decoded.getByteOffset());
        assertEquals(654321L, decoded.getLengthInBytes());
    }

        int decoded = resp.decode(buf, headerStart);
        assertTrue(decoded > 0, "Decode should return positive length");

        assertEquals(NtStatus.NT_STATUS_MORE_PROCESSING_REQUIRED, resp.getStatus());
        assertArrayEquals(blob, resp.getBlob(), "Security blob should match");
        assertEquals(sessionFlags, resp.getSessionFlags(), "Session flags should decode");

/**
 * Interface for objects that can be decoded from a byte buffer.
 * This interface provides methods for deserializing data from SMB protocol messages.
 *
 * @author mbechler
 */
public interface Decodable {

    /**
     * Decode data from a byte buffer
     *
     * @param buffer the byte buffer containing the data to decode
     * @param bufferIndex the starting index in the buffer

        // Byte count (2 bytes)
        buffer[53] = 0x00;
        buffer[54] = 0x00;

        // Test decode
        int bytesDecoded = response.decode(buffer, 0);

        // Should decode at least the header
        assertTrue(bytesDecoded > 0);

        // Verify the command was decoded correctly
        assertEquals(ServerMessageBlock.SMB_COM_TRANSACTION2, response.getCommand());
    }

    @Test

            int decoded = decodedContext.decode(buffer, 0, encoded);

            assertEquals(encoded, decoded);
            assertArrayEquals(originalHashAlgos, decodedContext.getHashAlgos());
            assertArrayEquals(originalSalt, decodedContext.getSalt());
        }

        @Test
        @DisplayName("Should encode and decode correctly with multiple hash algorithms and large salt")

        when(mockDeferredBuffer.dec_ndr_string()).thenReturn("DecodedShare", "Decoded Remark");

        shareInfo1.decode(mockNdrBuffer);

        assertEquals("DecodedShare", shareInfo1.netname);
        assertEquals(2, shareInfo1.type);
        assertEquals("Decoded Remark", shareInfo1.remark);
        verify(mockNdrBuffer).align(4);
        verify(mockNdrBuffer, times(3)).dec_ndr_long();