int codePoint;
        // discard illegal surrogate "codepoints"
        do {
          codePoint = rnd.nextInt(maxCodePoint.value);
        } while (Character.isSurrogate((char) codePoint));
        sb.appendCodePoint(codePoint);
      }
      strings[i] = sb.toString();
    }
  }

  @Benchmark
  int hashUtf8(int reps) {
    int res = 0;

            if (targetUrl.indexOf('#') == -1) {
                final StringBuilder buf = new StringBuilder(value.length() + 100);
                for (final char c : value.toCharArray()) {
                    if (CharUtil.isUrlChar(c) || c == ' ') {
                        buf.append(c);
                    } else {
                        try {

 *
 * @author Adomas Paltanavicius
 */
@NullUnmarked
public class JoinerBenchmark {

  private static final String DELIMITER_STRING = ",";
  private static final char DELIMITER_CHARACTER = ',';

  private static final Joiner JOINER_ON_STRING = Joiner.on(DELIMITER_STRING);
  private static final Joiner JOINER_ON_CHARACTER = Joiner.on(DELIMITER_CHARACTER);

  @Param({"3", "30", "300"})

  static final ImmutableMap<String, String> TEST_STRINGS =
      ImmutableMap.<String, String>builder()
          .put("empty", "")
          .put("1 char", "0")
          .put("1 word", "hello")
          .put("2 words", "hello world")
          .put("\\n line break", "hello\nworld")
          .put("\\r line break", "hello\rworld")

/**
 * Extracts non-overlapping substrings from an input string, typically by recognizing appearances of
 * a <i>separator</i> sequence. This separator can be specified as a single {@linkplain #on(char)
 * character}, fixed {@linkplain #on(String) string}, {@linkplain #onPattern regular expression} or
 * {@link #on(CharMatcher) CharMatcher} instance. Or, instead of using a separator at all, a

    scratch.putLong(l);
    return update(scratch, Longs.BYTES);
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putChar(char c) {
    ByteBuffer scratch = scratch();
    scratch.putChar(c);
    return update(scratch, Chars.BYTES);
  }

  private ByteBuffer scratch() {
    if (scratch == null) {
      scratch = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
    }

      }
    }
  }

  @AndroidIncompatible // slow
  @GwtIncompatible // Doubles.tryParse
  public void testTryParseAllCodePoints() {
    // Exercise non-ASCII digit test cases and the like.
    char[] tmp = new char[2];
    for (int i = Character.MIN_CODE_POINT; i < Character.MAX_CODE_POINT; i++) {
      Character.toChars(i, tmp, 0);
      checkTryParse(String.copyValueOf(tmp, 0, Character.charCount(i)));
    }
  }

        assertArrayEquals(expectedBytes, actualBytes);

        // Verify it's actually UTF-16LE (each ASCII char should be followed by 0x00)
        int pathStart = Smb2Constants.SMB2_HEADER_LENGTH + 8;
        for (int i = 0; i < testPath.length(); i++) {
            char c = testPath.charAt(i);
            if (c < 128) { // ASCII character
                assertEquals(c, buffer[pathStart + i * 2]);

            while ((pos = decoded.indexOf('%', pos + 1)) >= 0) {
                if (pos + 2 < decoded.length()) {
                    String hexStr = decoded.substring(pos + 1, pos + 3);
                    char ch = (char) Integer.parseInt(hexStr, 16);
                    decoded = decoded.substring(0, pos) + ch + decoded.substring(pos + 3);
                }
            }
        }
        return decoded;
    }

 * multiple threads.
 *
 * <p>Because, in general, escaping operates on the code points of a string and not on its
 * individual {@code char} values, it is not safe to assume that {@code escape(s)} is equivalent to
 * {@code escape(s.substring(0, n)) + escape(s.substring(n))} for arbitrary {@code n}. This is