}

    @Test
    public void testContentCache() {
        CurlResponse response = new CurlResponse();
        byte[] data = "test content".getBytes();
        ContentCache cache = new ContentCache(data);

        response.setContentCache(cache);

        // ContentCache is not directly accessible, but we can test through content methods

        }
    }

    @ParameterizedTest(name = "getType returns {0}")
    @ValueSource(ints = { 0, 1, -5, Integer.MAX_VALUE })
    @DisplayName("Parameterized type values")
    void typeParameterized(int type) {
        FileEntry mock = mock(FileEntry.class);
        when(mock.getType()).thenReturn(type);
        assertEquals(type, mock.getType());
    }

    @Test

      new SecretKeySpec("secret key".getBytes(UTF_8), "HmacMD5");
  private static final SecretKey SHA1_KEY =
      new SecretKeySpec("secret key".getBytes(UTF_8), "HmacSHA1");
  private static final SecretKey SHA256_KEY =
      new SecretKeySpec("secret key".getBytes(UTF_8), "HmacSHA256");
  private static final SecretKey SHA512_KEY =
      new SecretKeySpec("secret key".getBytes(UTF_8), "HmacSHA512");

    }

    public void test_name() {
        assertEquals("textTransformer", textTransformer.getName());
    }

    public void test_transform_text() throws Exception {
        final byte[] data = new String("xyz").getBytes();
        final ResponseData responseData = new ResponseData();
        responseData.setUrl("file:/test.txt");
        responseData.setCharSet(Constants.UTF_8);
        responseData.setResponseBody(data);

    assertTrue(
        from.getType() + " is expected to be assignable to " + to.getType(),
        to.isSupertypeOf(from));
    assertTrue(
        to.getType() + " is expected to be a supertype of " + from.getType(),
        to.isSupertypeOf(from));
    assertTrue(
        from.getType() + " is expected to be a subtype of " + to.getType(), from.isSubtypeOf(to));
  }

        }

        @Test
        @DisplayName("getBytes should encode string with specified charset")
        void testGetBytesWithCharset() {
            // When
            byte[] utf8Bytes = Strings.getBytes(TEST_STRING, StandardCharsets.UTF_8);
            byte[] utf16Bytes = Strings.getBytes(TEST_STRING, StandardCharsets.UTF_16LE);

            // Then

    @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");

        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\":{");

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

     */
    public static boolean contains(final List<AvPair> pairs, final int type) {
        if (pairs == null) {
            return false;
        }
        for (final AvPair p : pairs) {
            if (p.getType() == type) {
                return true;
            }
        }
        return false;
    }

    /**
     * Gets the first AV pair of the specified type from the list
     *