public static Joiner on(String separator) {
    return new Joiner(separator);
  }

  /** Returns a joiner which automatically places {@code separator} between consecutive elements. */
  public static Joiner on(char separator) {
    return new Joiner(String.valueOf(separator));
  }

  private final String separator;

  private Joiner(String separator) {
    this.separator = checkNotNull(separator);
  }

    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(new byte[] {1, 2, 3, 4, 5, 6, 7, 8});
  }

  public void testChar() {
    Sink sink = new Sink(4);
    sink.putChar((char) 0x0201);
    HashCode unused = sink.hash();
    sink.assertInvariants(2);
    sink.assertBytes(new byte[] {1, 2, 0, 0}); // padded with zeros
  }

  public void testString() {
    Random random = new Random();

     */
    protected String generateId(final String urlId) {
        final StringBuilder encodedBuf = new StringBuilder(urlId.length() + 100);
        for (int i = 0; i < urlId.length(); i++) {
            final char c = urlId.charAt(i);
            if (c >= 'a' && c <= 'z' //
                    || c >= 'A' && c <= 'Z' //
                    || c >= '0' && c <= '9' //
                    || c == '.' //

@J2ktIncompatible
@GwtIncompatible
public final class InetAddresses {
  private static final int IPV4_PART_COUNT = 4;
  private static final int IPV6_PART_COUNT = 8;
  private static final char IPV4_DELIMITER = '.';
  private static final char IPV6_DELIMITER = ':';
  private static final CharMatcher IPV4_DELIMITER_MATCHER = CharMatcher.is(IPV4_DELIMITER);
  private static final CharMatcher IPV6_DELIMITER_MATCHER = CharMatcher.is(IPV6_DELIMITER);

    private final Map<String, byte[]> rawKeys = new ConcurrentHashMap<>();
    private final SecureRandom secureRandom = new SecureRandom();
    private KeyStore keyStore;
    private char[] keyStorePassword;
    private volatile boolean closed = false;

    /**
     * Create a secure key manager without KeyStore
     */
    public SecureKeyManager() {
        this.keyStore = null;

     * @param out the writer
     * @return the number of characters copied
     */
    protected static int copyInternal(final Reader in, final Writer out) {
        try {
            final char[] buf = new char[DEFAULT_BUF_SIZE];
            int len;
            int amount = 0;
            while ((len = in.read(buf)) != -1) {
                out.write(buf, 0, len);
                amount += len;
            }

    private String unescape(final String s) {
        if (s.indexOf('\\') >= 0) {
            final StringBuilder sb = new StringBuilder();
            for (int i = 0; i < s.length(); i++) {
                final char ch = s.charAt(i);
                if (ch == '\\' && i < s.length() - 1) {
                    i++;
                    sb.append(s.charAt(i));
                } else {
                    sb.append(ch);

            return doNameQuery(new Name(host, type, scope), svr);
        }
        int IP = 0x00;
        int hitDots = 0;
        final char[] data = host.toCharArray();

        for (int i = 0; i < data.length; i++) {
            char c = data[i];
            if (c < 48 || c > 57) {
                return doNameQuery(new Name(host, type, scope), svr);
            }
            int b = 0x00;

    @Override
    public String firstCalledName() {

        this.calledName = this.hostName.name;

        if (Character.isDigit(this.calledName.charAt(0))) {
            int i, len, dots;
            char[] data;

            i = dots = 0; /* quick IP address validation */
            len = this.calledName.length();
            data = this.calledName.toCharArray();

    assertEquals(Object[].class, TypeToken.of(Object[][].class).getComponentType().getType());
    assertEquals(char.class, TypeToken.of(char[].class).getComponentType().getType());
    assertEquals(char[].class, TypeToken.of(char[][].class).getComponentType().getType());
    assertEquals(byte.class, TypeToken.of(byte[].class).getComponentType().getType());