return false;
            }
        }
        return true;
    }

    private static boolean isAsciiPrintable(final char ch) {
        return ch >= 32 && ch < 127;
    }

    /**
     * Creates a new String from a char array without copying the array.
     * <p>
     * This method uses internal JDK APIs and may not be available in all Java versions.

  private final char[][] replacements;
  // The number of elements in the replacement array.
  private final int replacementsLength;
  // The first code point in the safe range.
  private final int safeMin;
  // The last code point in the safe range.
  private final int safeMax;

  // Cropped values used in the fast path range checks.
  private final char safeMinChar;
  private final char safeMaxChar;

        // Test integer conversion
        char[] dst1 = new char[8];
        Hexdump.toHexChars(0x1234ABCD, dst1, 0, 8);
        assertEquals("1234ABCD", new String(dst1));

        // Test with smaller size
        char[] dst2 = new char[4];
        Hexdump.toHexChars(0xABCD, dst2, 0, 4);
        assertEquals("ABCD", new String(dst2));

        // Test with offset
        char[] dst3 = new char[10];

            int i = 0;
            do {
                if (i >= buf.length) {
                    final char[] nb = new char[buf.length * 2];
                    System.arraycopy(buf, 0, nb, 0, buf.length);
                    buf = nb;
                }
                buf[i++] = (char) peekc;
                peekc = read();
                peekct = peekc < 0 ? CT_WHITESPACE : peekc < 256 ? ctype[peekc] : CT_ALPHA;

  static long copyReaderToBuilder(Reader from, StringBuilder to) throws IOException {
    checkNotNull(from);
    checkNotNull(to);
    char[] buf = new char[DEFAULT_BUF_SIZE];
    int nRead;
    long total = 0;
    while ((nRead = from.read(buf)) != -1) {
      to.append(buf, 0, nRead);
      total += nRead;
    }
    return total;
  }

  /**

        hashFunction.newHasher().putUnencodedChars(string).hash());
  }

  static char randomLowSurrogate(Random random) {
    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

     * @return a hexadecimal string representation of the value, padded to the specified size
     */
    public static String toHexString(final int val, final int size) {
        final char[] c = new char[size];
        toHexChars(val, c, 0, size);
        return new String(c);
    }

    /**
     * Converts a long value to a hexadecimal string representation with specified padding.
     *

 * limitations under the License.
 */

package com.google.common.escape;

/**
 * @author Jesse Wilson
 */
final class Platform {

  private static final char[] CHAR_BUFFER = new char[1024];

  static char[] charBufferFromThreadLocal() {
    // ThreadLocal is not available to GWT, so we always reuse the same
    // instance.  It is always safe to return the same instance because

    }
  }

  public void testUtf8() {
    char[] charsA = new char[128];
    char[] charsB = new char[128];

    for (int i = 0; i < charsA.length; i++) {
      if (i < 100) {
        charsA[i] = 'a';
        charsB[i] = 'a';
      } else {
        // Both two-byte characters, but must be different
        charsA[i] = (char) (0x0180 + i);
        charsB[i] = (char) (0x0280 + i);
      }
    }

    /**
     * Performs constant-time comparison of two char arrays to prevent timing attacks.
     * This method always compares the full length of both arrays, regardless of when
     * differences are found, making the execution time independent of the position
     * of differing characters.
     *
     * @param a first char array to compare
     * @param b second char array to compare
     * @return true if arrays are equal, false otherwise