* <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1">defined by HTTP/1.1</a>.
 * As such, the {@code *} character is treated as a wildcard and is used to represent any acceptable
 * type or subtype value. A media type may not have wildcard type with a declared subtype. The
 * {@code *} character has no special meaning as part of a parameter. All values for type, subtype,

    }

    public void test_sizeOf_stringVariations() {
        // Empty string
        assertEquals(56L, MemoryUtil.sizeOf(""));

        // Single character
        assertEquals(57L, MemoryUtil.sizeOf("a"));

        // Unicode characters
        assertEquals(58L, MemoryUtil.sizeOf("こん"));

        // Very long string
        StringBuilder longString = new StringBuilder();

        ImmutableListMultimap.of("foo", 'f', "foo", 'o', "foo", 'o').inverse());
  }

  public void testInverseMinimizesWork() {
    ImmutableListMultimap<String, Character> multimap =
        ImmutableListMultimap.<String, Character>builder()
            .put("foo", 'f')
            .put("foo", 'o')
            .put("foo", 'o')
            .put("poo", 'p')
            .put("poo", 'o')

        final StringBuilder buf = new StringBuilder(pattern.length());
        for (int i = 0; i < pattern.length(); ++i) {
            final char ch = pattern.charAt(i);
            if (Character.isLetterOrDigit(ch) || Character.isWhitespace(ch)) {
                buf.append(ch);
            }
        }
        if (buf.indexOf("HH") == -1) {
            final int pos = buf.indexOf("H");
            if (pos != -1) {

        final StringBuilder buf = new StringBuilder(pattern.length());
        for (int i = 0; i < pattern.length(); ++i) {
            final char ch = pattern.charAt(i);
            if (Character.isLetterOrDigit(ch) || Character.isWhitespace(ch)) {
                buf.append(ch);
            }
        }
        if (buf.indexOf("yy") == -1) {
            final int pos = buf.indexOf("y");
            if (pos != -1) {

        String str = info.toString();

        // Verify type is displayed as hex
        assertNotNull(str);
        assertTrue(str.contains("type=0x"));
        // The type should be formatted as 8-character hex
        String expectedHex = String.format("%08x", type);
        assertTrue(str.toLowerCase().contains(expectedHex));
    }

    @Test
    @DisplayName("Test with empty strings")

 * FormScheme formScheme = new FormScheme(params);
 * formScheme.authenticate(credentials, executor);
 * }
 * </pre>
 *
 * <p>Parameters:
 * <ul>
 * <li>ENCODING - The character encoding to use for request parameters.</li>
 * <li>TOKEN_URL - The URL to request the token from.</li>
 * <li>TOKEN_PATTERN - The regex pattern to extract the token from the response.</li>

          if (labels[currentLabelIndex].size == currentLabelByteIndex) {
            // We've exhausted our current label. Either there are more labels to compare, in which
            // case we expect a dot as the next character. Otherwise, we've checked all our labels.
            if (currentLabelIndex == labels.size - 1) {
              break
            } else {
              currentLabelIndex++
              currentLabelByteIndex = -1

            assertNotNull(enumInstance.info);
        }
    }

    @Test
    @DisplayName("getEntries should properly convert DFS roots with special characters")
    void testGetEntries_specialCharacters() throws Exception {
        // Create array with special character names
        netdfs.DfsEnumArray200 specialArray = new netdfs.DfsEnumArray200();
        specialArray.count = 3;
        specialArray.s = new netdfs.DfsInfo200[3];

        if (host == null || host.length() == 0) {
            return getLocalHost();
        }

        final Name name = new Name(this.transportContext.getConfig(), host, type, scope);
        if (!Character.isDigit(host.charAt(0))) {
            return doNameQuery(name, svr);
        }

        int IP = 0x00;
        int hitDots = 0;
        final char[] data = host.toCharArray();