}
                    ip = (ip << 8) + b;
                }
                while (i < data.length && Character.isWhitespace(data[i])) {
                    i++;
                }
                j = i;
                while (j < data.length && !Character.isWhitespace(data[j])) {
                    j++;
                }

   *
   * @throws NumberFormatException if the string does not contain a parsable unsigned {@code long}
   *     value, or {@code radix} is not between {@link Character#MIN_RADIX} and {@link
   *     Character#MAX_RADIX}
   */
  @CanIgnoreReturnValue
  public static UnsignedLong valueOf(String string, int radix) {
    return fromLongBits(UnsignedLongs.parseUnsignedLong(string, radix));
  }

    }

    /**
     * SAX event handler called to process character data between XML elements.
     * Accumulates text content in a buffer for later processing when the element ends.
     *
     * @param ch the characters from the XML document
     * @param start the start position in the character array
     * @param length the number of characters to use from the character array

   *                  str -> str.substring(1).chars().mapToObj(c -> (char) c));
   *
   * // is equivalent to
   *
   * static final ImmutableSetMultimap<Character, Character> FIRST_LETTER_MULTIMAP =
   *     ImmutableSetMultimap.<Character, Character>builder()
   *         .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
   *         .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
   *         .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))

/**
 * @author David Beaumont
 */
@GwtCompatible
@NullMarked
public class ArrayBasedCharEscaperTest extends TestCase {
  private static final ImmutableMap<Character, String> NO_REPLACEMENTS = ImmutableMap.of();
  private static final ImmutableMap<Character, String> SIMPLE_REPLACEMENTS =
      ImmutableMap.of(
          '\n', "<newline>",
          '\t', "<tab>",
          '&', "<and>");

 *
 * <p><b>Warning:</b> Using a specific character encoding when hashing a {@link CharSequence} with
 * {@link #putString(CharSequence, Charset)} is generally only useful for cross-language
 * compatibility (otherwise prefer {@link #putUnencodedChars}). However, the character encodings
 * must be identical across languages. Also beware that {@link Charset} definitions may occasionally

    "output": null
  },
  {
    "input": "xn--a.ß",
    "output": null
  },
  {
    "input": "xn--ls8h=",
    "output": null
  },
  {
    "comment": "Invalid Punycode (contains non-ASCII character)",
    "input": "xn--tešla",
    "output": null
  },
  {
    "comment": "Valid Punycode",
    "input": "xn--zca.xn--zca",
    "output": "xn--zca.xn--zca"
  },
  {
    "comment": "Mixed",

     * @return Separator for grouping
     */
    public static String findGroupingSeparator(final Locale locale) {
        final DecimalFormatSymbols symbol = getDecimalFormatSymbols(locale);
        return Character.toString(symbol.getGroupingSeparator());
    }

    /**
     * Returns the separator for decimal numbers.
     *
     * @param locale
     *            Locale
     * @return Separator for decimal numbers

  public ArrayTableRowMapTest() {
    super(true, false, false, false);
  }

  @Override
  Table<String, Integer, Character> makeTable() {
    return ArrayTable.create(asList("foo", "bar", "dog"), asList(1, 2, 3));
  }

  @Override
  protected Map<String, Map<Integer, Character>> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

    return (char)
        (Character.MIN_LOW_SURROGATE
            + random.nextInt(Character.MAX_LOW_SURROGATE - Character.MIN_LOW_SURROGATE + 1));
  }

  static char randomHighSurrogate(Random random) {
    return (char)
        (Character.MIN_HIGH_SURROGATE
            + random.nextInt(Character.MAX_HIGH_SURROGATE - Character.MIN_HIGH_SURROGATE + 1));
  }