buf.append("\"memory\":{");
        buf.append("\"heap\":{");
        append(buf, "used", () -> mem.getHeapUsed().getBytes()).append(',');
        append(buf, "committed", () -> mem.getHeapCommitted().getBytes()).append(',');
        append(buf, "max", () -> mem.getHeapMax().getBytes()).append(',');
        append(buf, "percent", () -> mem.getHeapUsedPercent());
        buf.append("},");
        buf.append("\"non_heap\":{");

    assertThat(fingerprint(stringA.getBytes(UTF_8)))
        .isNotEqualTo(fingerprint(stringB.getBytes(UTF_8)));

    // ISO 8859-1 only has 0-255 (ubyte) representation so throws away UTF-8 characters
    // greater than 127 (ie with their top bit set).
    // Don't attempt to do this in real code.
    assertEquals(
        fingerprint(stringA.getBytes(ISO_8859_1)), fingerprint(stringB.getBytes(ISO_8859_1)));
  }

    public String toString() {
        return getGroupId() + ":" + getArtifactId() + ":" + getVersion() + ":"
                + (getClassifier() == null ? "" : getClassifier()) + ":"
                + (getType() == null ? DEFAULT_TYPE : getType());
    }

                if (lastItem.isNull()) {
                    if (i == size() - 1 || get(i + 1).getType() == STRING_ITEM) {
                        remove(i);
                    } else if (get(i + 1).getType() == LIST_ITEM) {
                        Item item = ((ListItem) get(i + 1)).get(0);
                        if (item.getType() == COMBINATION_ITEM || item.getType() == STRING_ITEM) {
                            remove(i);
                        }

        System.arraycopy("SHARE1".getBytes(StandardCharsets.US_ASCII), 0, data, 0, 6);
        data[14] = 0x00;
        data[15] = 0x00; // type = 0
        data[16] = 40;
        data[17] = 0;
        data[18] = 0;
        data[19] = 0; // remark offset

        // Entry 2: IPC$, type 3 (IPC), remark "Inter-Process Communication"
        System.arraycopy("IPC$".getBytes(StandardCharsets.US_ASCII), 0, data, 20, 4);

        response.byteCount = 15; // 8 bytes key + 6 bytes "DOMAIN" + 1 null terminator

        // Prepare byte array
        byte[] encryptionKey = "12345678".getBytes();
        byte[] domainNameBytes = "DOMAIN".getBytes(ServerMessageBlock.OEM_ENCODING);
        ByteBuffer buffer = ByteBuffer.allocate(response.byteCount);
        buffer.put(encryptionKey);
        buffer.put(domainNameBytes);

        String name1 = "WORKSTATION     ";
        System.arraycopy(name1.getBytes("US-ASCII"), 0, src, srcIndex + 1, 16);
        src[srcIndex + 16] = 0x00; // hex code
        src[srcIndex + 17] = 0x04; // flags: active

        // Second name entry (18 bytes)
        String name2 = "DOMAIN          ";
        System.arraycopy(name2.getBytes("US-ASCII"), 0, src, srcIndex + 19, 16);
        src[srcIndex + 34] = 0x00; // hex code

    @DisplayName("Should calculate HMAC-T64 correctly")
    void testHMACT64() {
        // Given
        byte[] key = "secret".getBytes();
        byte[] data = "Hello World".getBytes();

        // When
        MessageDigest hmac = Crypto.getHMACT64(key);
        byte[] result = hmac.digest(data);

        // Then
        assertNotNull(result);
        assertTrue(result.length > 0, "HMAC-T64 should produce non-empty result");

        int type = AvPair.MsvAvTimestamp;
        byte[] raw = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        AvPair avPair = new AvPair(type, raw);

        assertEquals(type, avPair.getType(), "Type should match the constructor argument.");
        assertArrayEquals(raw, avPair.getRaw(), "Raw data should match the constructor argument.");

        // Test with another type and empty raw data

        // ## Arrange ##
        byte[] data = "original".getBytes("UTF-8");
        ContentCache cache = new ContentCache(data);

        // ## Act ##
        byte[] result = cache.getContentAsBytes();
        result[0] = 'X';

        // ## Assert ##
        byte[] secondResult = cache.getContentAsBytes();
        assertArrayEquals("original".getBytes("UTF-8"), secondResult);
    }

    @Test