// Prepare test data
        String filename = "testfile.txt";
        byte[] buffer = createValidBuffer(filename, "TESTFI~1.TXT", true);

        // Decode and check return value
        int bytesConsumed = fileBothDirectoryInfo.decode(buffer, 0, buffer.length);

        // Verify bytes consumed matches the actual data size

    }
    File file = out.getFile();
    assertNull(file);

    // Write data to go over the threshold
    if (chunk2 > 0) {
      if (JAVA_IO_TMPDIR.value().equals("/sdcard")) {
        assertThrows(IOException.class, () -> write(out, data, chunk1, chunk2, singleByte));
        return;
      }
      write(out, data, chunk1, chunk2, singleByte);
      file = out.getFile();

      type: "get",
      timeoutNumber: 10000,
      url: contextPath + "/api/v1/favorites",
      data: {
        queryId: $queryId.val()
      }
    })
      .done(function(data) {
        var docIds,
            i;
        if (data.record_count > 0) {
          docIds = data.data;
          for (i = 0; i < docIds.length; i++) {
            docIds[i] = "#" + docIds[i].doc_id;
          }

            byte[] signature = mac.doFinal();

            // Place signature in data
            System.arraycopy(signature, 0, data, SIGNATURE_OFFSET, SIGNATURE_LENGTH);

            boolean result = digest.verify(data, 0, data.length, 0, msg);

            // FIXED: Should return true for valid signature (was previously expecting false)
            assertTrue(result, "Should return true for valid signature");

    /**
     * Encrypts the given data.
     *
     * @param data
     *            the data to encrypt
     * @return the encrypted data
     */
    public byte[] encrypto(final byte[] data) {
        final Cipher cipher = pollEncryptoCipher();
        byte[] encrypted;
        try {
            encrypted = cipher.doFinal(data);
        } catch (final IllegalBlockSizeException e) {

  fun multiline() {
    consumeEvents(
      """
      |data: YHOO
      |data: +2
      |data: 10
      |
      |
      """.trimMargin(),
    )
    assertThat(callbacks.remove()).isEqualTo(Event(null, null, "YHOO\n+2\n10"))
  }

  @Test
  fun multilineCr() {
    consumeEvents(
      """
      |data: YHOO
      |data: +2
      |data: 10
      |
      |
      """.trimMargin().replace("\n", "\r"),

     * Calculates a Message Integrity Code (MIC) for the given data.
     * @param data the data to calculate MIC for
     * @return MIC
     * @throws CIFSException if an error occurs calculating the MIC
     */
    byte[] calculateMIC(byte[] data) throws CIFSException;

    /**
     * Verifies a Message Integrity Code (MIC) for the given data.
     * @param data the data to verify
     * @param mic the MIC to verify against

import jakarta.annotation.Resource;

/**
 * Service class for managing data configuration CRUD operations.
 * This service provides functionality to create, read, update, and delete
 * data configurations used by the Fess crawler system.
 *
 * <p>Data configurations define how the crawler should access and process
 * various data sources such as databases, CSV files, or other structured data.</p>
 */
public class DataConfigService extends FessAppService {

        return this.fileId;
    }

    /**
     * Gets the decoded output data from the response.
     *
     * @return the outputData
     */
    public Decodable getOutputData() {
        return this.outputData;
    }

    /**
     * Gets the length of the output data.
     *
     * @return the outputLength
     */
    public int getOutputLength() {

        byte[] key = new byte[16];
        Arrays.fill(key, (byte) 0x0b);
        byte[] data = "Hi There".getBytes();

        // Expected result calculated manually for HMACT64 with this key and data
        HMACT64 hmac = new HMACT64(key);
        hmac.engineUpdate(data, 0, data.length);
        byte[] result = hmac.engineDigest();

        // Verify it produces a valid MD5 hash (16 bytes)