// Verify encoded length
        assertEquals(3, encodedLen, "Encoded length should be equal to the specified length");

        // Verify content
        assertArrayEquals(new byte[] { (byte) 0xFF, 0x01, 0x02, 0x03, 0x00 }, dest, "Encoded bytes should be placed at the correct offset");
    }

    @Test
    void testEncodeZeroLength() {
        // Test encoding with zero length
        byte[] data = { 0x01, 0x02, 0x03 };

        System.arraycopy(testData, 0, buffer, 10, testData.length);

        int result = response.readDataWireFormat(buffer, 10, testData.length);

        assertEquals(testData.length, result);
        // Verify data was copied to outputBuffer
        byte[] expectedData = new byte[testData.length];
        System.arraycopy(outputBuffer, 0, expectedData, 0, testData.length);
        assertArrayEquals(testData, expectedData);
    }

        byte[] packet = new byte[header.length + body.length];
        System.arraycopy(header, 0, packet, 0, header.length);
        System.arraycopy(body, 0, packet, header.length, body.length);

        BaseConfiguration config = new BaseConfiguration(true);
        byte[] outBuf = new byte[output.length];

        }
        if (isDirect) {
            out.writeDirect(buf, off, length, 1);
            return;
        }
        out.write(buf, off, length);
    }

    @Override
    protected void doReceiveFragment(final byte[] buf, final boolean isDirect) throws IOException {
        int off, flags, length;

        if (buf.length < max_recv) {
            throw new IllegalArgumentException("buffer too small");
        }

        assertFalse(result.isEmpty());
        assertEquals(size * 2, result.length()); // Each byte becomes 2 hex chars
    }

    @Test
    @DisplayName("Should format with specific offset and length")
    void testHexdumpWithOffsetAndLength() {
        // Given
        byte[] data = createTestData(64);
        int offset = 16;
        int length = 32;

        // When

        byte[] outputBuffer = new byte[testData.length + 100];
        int writtenBytes =
                compressionService.decompress(compressed, 0, compressed.length, outputBuffer, 50, CompressionService.COMPRESSION_LZ77);

        assertEquals(testData.length, writtenBytes);

        byte[] extracted = new byte[testData.length];
        System.arraycopy(outputBuffer, 50, extracted, 0, testData.length);

   */
  static @Nullable Object[] copyAsObjectArray(@Nullable Object[] elements, int offset, int length) {
    checkPositionIndexes(offset, offset + length, elements.length);
    if (length == 0) {
      return new Object[0];
    }
    @Nullable Object[] result = new Object[length];
    arraycopy(elements, offset, result, 0, length);
    return result;
  }

  @CanIgnoreReturnValue

                final byte[] output = new byte[cipher.getOutputSize(input.length)];
                int len = cipher.processBytes(input, 0, input.length, output, 0);
                len += cipher.doFinal(output, len);

                plaintext = new byte[ciphertext.length];
                System.arraycopy(output, 0, plaintext, 0, ciphertext.length);
            }

        // Skip 8 bytes for RootDirectory (8-15)
        SMBUtil.writeInt4(nameBytes.length, buffer, 16);
        System.arraycopy(nameBytes, 0, buffer, 20, nameBytes.length);

        FileRenameInformation2 info = new FileRenameInformation2();
        int bytesRead = info.decode(buffer, 0, buffer.length);

        assertEquals(20 + nameBytes.length, bytesRead);
    }

    @Test

        // Simulate a security buffer structure: length (2 bytes), length (2 bytes), offset (4 bytes)
        // Length = 5, Offset = 8
        ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);
        buffer.putShort(0, (short) content.length); // Length
        buffer.putShort(2, (short) content.length); // MaxLength (not used by readSecurityBuffer, but typically same as length)
        buffer.putInt(4, 8); // Offset