byte[] mac = PacMac.calculateMacArcfourHMACMD5(3, key, TEST_DATA);
        assertNotNull(mac);
        assertEquals(16, mac.length);

        // Test with a different key usage
        byte[] mac2 = PacMac.calculateMacArcfourHMACMD5(9, key, TEST_DATA);
        assertNotNull(mac2);
        assertEquals(16, mac2.length);

        // Test with another key usage
        byte[] mac3 = PacMac.calculateMacArcfourHMACMD5(23, key, TEST_DATA);

     * @param length maximum length to receive
     * @return number of bytes received
     * @throws IOException if an I/O error occurs
     */
    int recv(byte[] buf, int off, int length) throws IOException;

    /**
     * Send data to the pipe
     *
     * @param buf buffer containing data to send
     * @param off offset in the buffer
     * @param length length of data to send

        @Test
        @DisplayName("Should handle negative length in verify method")
        void testVerifyNegativeLength() {
            byte[] data = new byte[128];
            boolean result = digest.verify(data, 0, -1, 0, response);
            assertFalse(result, "Should return false for negative length");
        }

        @Test
        @DisplayName("Should handle offset+length exceeding buffer size in verify method")

        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);
    }

        this.num_sids = sids.length;
        this.sids = new lsarpc.LsarSidPtr[sids.length];
        for (int si = 0; si < sids.length; si++) {
            this.sids[si] = new lsarpc.LsarSidPtr();
            this.sids[si].sid = sids[si].unwrap(sid_t.class);
        }
    }

    LsarSidArrayX(final SID[] sids) {
        this.num_sids = sids.length;
        this.sids = new lsarpc.LsarSidPtr[sids.length];

  public final Entry<String, String>[] createArray(int length) {
    return (Entry<String, String>[]) new Entry<?, ?>[length];
  }

  @Override
  public final String[] createKeyArray(int length) {
    return new String[length];
  }

  @Override
  public final String[] createValueArray(int length) {
    return new String[length];
  }

  /** Returns the original element list, unchanged. */
  @Override

                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);
            }

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

            int offset = 50;
            int length = 100;
            request.setData(fullData, offset, length);

            byte[] buffer = new byte[512];
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);

            // Verify only the specified portion is written
            assertEquals(48 + length, bytesWritten);

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