}

	// If we cannot decode, just return read quorum error.
	return nil, fmt.Errorf("%w (offline-disks=%d/%d)", errErasureReadQuorum, disksNotFound, len(p.readers))
}

// Decode reads from readers, reconstructs data if needed and writes the data to the writer.
// A set of preferred drives can be supplied. In that case they will be used and the data reconstructed.

        // Encode
        byte[] buffer = new byte[8];
        int encoded = original.encode(buffer, 0);
        assertEquals(8, encoded);

        // Decode
        FileEndOfFileInformation decoded = new FileEndOfFileInformation();
        int decodedBytes = decoded.decode(buffer, 0, 8);
        assertEquals(8, decodedBytes);

        NdrHyper decoded = new NdrHyper(0);
        decoded.decode(buf);
        assertEquals(val, decoded.value, "Decoded value should match encoded value for " + Long.toHexString(val));
    }

    /**
     * Ensure encode throws NPE when passed a null buffer.
     */
    @Test
    @DisplayName("Encode with null buffer throws NullPointerException")
    public void testEncodeNullBuffer() throws NdrException {

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

            assertEquals(encoded, decoded);
            assertArrayEquals(originalCiphers, decodedContext.getCiphers());
        }

        @Test
        @DisplayName("Should encode and decode correctly with null ciphers")

        FileBasicInfo decoded = new FileBasicInfo();
        int decodedBytes = decoded.decode(buffer, 0, 36);

        // Verify encoding/decoding
        assertEquals(40, encodedBytes); // encode writes 40 bytes (includes padding)
        assertEquals(36, decodedBytes); // decode reads 36 bytes (no padding)
        assertEquals(original.getCreateTime(), decoded.getCreateTime());

        SMBUtil.writeInt8(expectedValue, buffer, offset);

        // Decode from offset
        int bytesRead = fileInfo.decode(buffer, offset, buffer.length - offset);

        assertEquals(8, bytesRead);
        assertTrue(fileInfo.toString().contains("endOfFile=" + expectedValue));
    }

    @Test
    @DisplayName("Test encode and decode round trip")

        FileRenameInformation2 original = new FileRenameInformation2(fileName, replaceIfExists);

        // Encode
        byte[] buffer = new byte[200];
        int bytesWritten = original.encode(buffer, 0);

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

        // Verify round trip
        assertEquals(bytesWritten, bytesRead);

        // Encode to buffer
        byte[] buffer = new byte[1024];
        NdrBuffer encodeBuffer = new NdrBuffer(buffer, 0);
        domainInfo.encode(encodeBuffer);

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

        void testEmptyArraysEncodeDecode() throws SMBProtocolDecodingException {
            context = new PreauthIntegrityNegotiateContext(mockConfig, new int[0], new byte[0]);
            int encodedSize = context.encode(buffer, 0);

            PreauthIntegrityNegotiateContext decoded = new PreauthIntegrityNegotiateContext();
            int decodedSize = decoded.decode(buffer, 0, encodedSize);

    }

    /**
     * Test decode with only EOL
     */
    @Test
    @DisplayName("Decode empty list with only EOL")
    void testDecodeEmptyList() throws CIFSException {
        byte[] eolData = createEolData();
        List<AvPair> pairs = AvPairs.decode(eolData);

        assertNotNull(pairs, "Decoded pairs should not be null");