} else {
			err = erasure.DecodeDataBlocks(encoded)
		}

		if err == nil && test.shouldFail {
			t.Errorf("Test %d: test should fail but it passed", i)
		}
		if err != nil && !test.shouldFail {
			t.Errorf("Test %d: test should pass but it failed: %v", i, err)
		}

		decoded := encoded
		if !test.shouldFail {
			if test.reconstructParity {
				for j := range decoded {
					if decoded[j] == nil {

/**
 * 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

     * Decodes a 32-bit unsigned integer from little-endian byte order.
     *
     * @param src the source byte array
     * @param si the starting index in the source array
     * @return the decoded integer value
     */
    public static int dec_uint32le(final byte[] src, final int si) {
        return src[si] & 0xFF | (src[si + 1] & 0xFF) << 8 | (src[si + 2] & 0xFF) << 16 | (src[si + 3] & 0xFF) << 24;
    }

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

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

        // Verify toString contains the value
        assertTrue(decoded.toString().contains(String.valueOf(endOfFile)));

      ).decodeBase64()!!

    val decoded = CertificateAdapters.privateKeyInfo.fromDer(privateKeyInfoByteString)

    assertThat(decoded.version).isEqualTo(0L)
    assertThat(decoded.algorithmIdentifier).isEqualTo(AlgorithmIdentifier(RSA_ENCRYPTION, null))
    assertThat(decoded.privateKey.size).isEqualTo(607)

    val encoded = CertificateAdapters.privateKeyInfo.toDer(decoded)

	input   chan simdjson.Stream
	decoded chan simdjson.Object

	// err will only be returned after decoded has been closed.
	err          *error
	readCloser   io.ReadCloser
	onReaderExit func()

	exitReader chan struct{}
	readerWg   sync.WaitGroup
}

// Read - reads single record.
func (r *Reader) Read(dst sql.Record) (sql.Record, error) {
	v, ok := <-r.decoded
	if !ok {
		if r.err != nil && *r.err != nil {

        // 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

            // Encode at position 200
            int encoded = context.encode(buffer, 200);
            assertEquals(2 + 4, encoded); // count + 2 ciphers

            // Decode and verify
            EncryptionNegotiateContext decoded = new EncryptionNegotiateContext();
            try {
                decoded.decode(buffer, 200, encoded);
                assertArrayEquals(ciphers, decoded.getCiphers());

        }
        return len;
    }

    /**
     * Decodes a string from OEM-encoded bytes.
     *
     * @param src the byte array containing the encoded string
     * @param srcIndex the starting offset in the byte array
     * @param len the number of bytes to decode
     * @param config the configuration providing the OEM encoding
     * @return decoded string
     */

        }

        /**
         * Gets the decoded name of this field facet.
         *
         * @return the field name
         */
        public String getName() {
            return name;
        }

    }

    /**
     * Gets the map of query facet counts.
     *
     * @return the queryCountMap containing decoded query strings and their counts
     */