assertTrue(value == 255, "Comparison should work correctly");
    }

    /**
     * Encode a string as 16-bit little-endian Unicode
     */
    private byte[] encodeUnicode(String s) {
        char[] chars = s.toCharArray();
        byte[] out = new byte[chars.length * 2];
        for (int i = 0; i < chars.length; i++) {
            out[2 * i] = (byte) (chars[i] & 0xFF);

        if (text == null || text.isEmpty()) {
            return "";
        }
        final StringBuilder sb = new StringBuilder(text.length());
        for (int i = 0; i < text.length(); i++) {
            final char c = text.charAt(i);
            switch (c) {
            case '"':
                sb.append("\\\"");
                break;
            case '\\':
                sb.append("\\\\");
                break;

        this.messageBuilderFactory = messageBuilderFactory;
        this.terminalWidth = terminalWidth;
    }

    private static String chars(char c, int count) {
        return String.valueOf(c).repeat(Math.max(0, count));
    }

    private void infoLine(char c) {
        infoMain(chars(c, lineLength));
    }

    private void infoMain(String msg) {
        logger.info(builder().strong(msg).toString());
    }

        assertEquals("http://example.com/path/[id]/page", result);
    }

    @Test
    public void test_encodeUrl_percentSign() {
        // CharUtil.isUrlChar treats % as valid URL char, so it passes through unchanged
        String result = DocumentUtil.encodeUrl("http://example.com/100%25/done");
        assertEquals("http://example.com/100%25/done", result);
    }

    @Test

  public long writeFrom(InputStream input) throws IOException {
    checkNotNull(input);

    try (OutputStream out = openStream()) {
      return ByteStreams.copy(input, out);
    }
  }

  /**
   * A char sink that encodes written characters with a charset and writes resulting bytes to this
   * byte sink.
   */
  private final class AsCharSink extends CharSink {

    private final Charset charset;

        if (System.getenv("MVNW_USERNAME") != null && System.getenv("MVNW_PASSWORD") != null) {
            String username = System.getenv("MVNW_USERNAME");
            char[] password = System.getenv("MVNW_PASSWORD").toCharArray();
            Authenticator.setDefault(new Authenticator() {
                @Override
                protected PasswordAuthentication getPasswordAuthentication() {

            if (ForbiddenApisPlugin.FORBIDDEN_APIS_TASK_NAME.equals(t.getName())) {
                sourceSetName = "main";
            } else {
                // parse out the sourceSetName
                char[] chars = t.getName().substring(ForbiddenApisPlugin.FORBIDDEN_APIS_TASK_NAME.length()).toCharArray();
                chars[0] = Character.toLowerCase(chars[0]);
                sourceSetName = new String(chars);
            }

    hasher.putLong(0x0807060504030201L);
    hasher.assertBytes(new byte[] {1, 2, 3, 4, 5, 6, 7, 8});
  }

  public void testChar() {
    TestHasher hasher = new TestHasher();
    hasher.putChar((char) 0x0201);
    hasher.assertBytes(new byte[] {1, 2});
  }

  public void testString() {
    Random random = new Random();
    for (int i = 0; i < 100; i++) {
      byte[] bytes = new byte[64];

                            String string = o.toString();
                            int i = string.length() - 1;
                            while (i >= 0) {
                                char c = string.charAt(i);
                                if (c == '\n' || c == '\r' || c == ' ') {
                                    i--;
                                } else {
                                    break;

  @JvmStatic
  fun headerEntries(vararg elements: String?): List<Header> = List(elements.size / 2) { Header(elements[it * 2]!!, elements[it * 2 + 1]!!) }

  @JvmStatic
  fun repeat(
    c: Char,
    count: Int,
  ): String {
    val array = CharArray(count)
    Arrays.fill(array, c)
    return String(array)
  }

  /**