this.scanner = scanner;
    }

    public void pushText(String rawCommentText) {
        scanner.pushText(rawCommentText);
    }

    @Override
    public void visit(TokenVisitor visitor) {
        while (!scanner.isEmpty()) {
            if (scanner.lookingAt(START_HTML_COMMENT)) {
                skipComment();
                continue;
            }
            if (scanner.lookingAt(HTML_ELEMENT)) {

                        //                      System.out.print('l');
                    } else if (r < 1.0) {
                        final InputStream in = f.getInputStream();
                        while (in.read(buf) > 0) {
                            //                          System.out.print('r');
                        }
                        in.close();
                    }

   * limits.
   */
  fun encode(string: String): String? {
    var pos = 0
    val limit = string.length
    val result = Buffer()

    while (pos < limit) {
      var dot = string.indexOf('.', startIndex = pos)
      if (dot == -1) dot = limit

      if (!encodeLabel(string, pos, dot, result)) {
        // If we couldn't encode the label, give up.

     * this file is open. This constant may be logically OR'd with other share
     * access flags.
     */
    public static final int FILE_SHARE_READ = 0x01;
    /**
     * When specified as the {@code shareAccess} constructor parameter,
     * other SMB clients will be permitted to write to the target file while

        if (low < 0) {
            low = 0;
        }
        if (hi >= ctype2.length) {
            hi = ctype2.length - 1;
        }
        while (low <= hi) {
            ctype2[low++] |= CT_ALPHA;
        }
    }

    /**
     * Sets a character as a word character.
     *
     * @param ctype2
     *            The array of character types.

  companion object {
    fun load(source: BufferedSource): List<WebPlatformUrlTestData> {
      val list = mutableListOf<WebPlatformUrlTestData>()
      while (true) {
        val line = source.readUtf8Line() ?: break
        if (line.isEmpty() || line.startsWith("#")) continue

        var i = 0
        val parts = line.split(Regex(" ")).toTypedArray()

      return !tasks.isEmpty();
    }

    void runNext() {
      assertTrue("expected at least one task to run", hasNext());
      tasks.remove().run();
    }

    void runAll() {
      while (hasNext()) {
        runNext();
      }
    }
  }

  private FakeExecutor fakePool;
  private SequentialExecutor e;

  @Override
  public void setUp() {
    fakePool = new FakeExecutor();

                        b = b * 10 + c - '0';
                    }
                    ip = (ip << 8) + b;
                }
                while (i < data.length && Character.isWhitespace(data[i])) {
                    i++;
                }
                j = i;
                while (j < data.length && !Character.isWhitespace(data[j])) {
                    j++;
                }

   * independent stream each time it is called.
   *
   * <p>The caller is responsible for ensuring that the returned stream is closed.
   *
   * @throws IOException if an I/O error occurs while opening the stream
   */
  public abstract OutputStream openStream() throws IOException;

  /**
   * Opens a new buffered {@link OutputStream} for writing to this sink. The returned stream is not

   * independent stream each time it is called.
   *
   * <p>The caller is responsible for ensuring that the returned stream is closed.
   *
   * @throws IOException if an I/O error occurs while opening the stream
   */
  public abstract OutputStream openStream() throws IOException;

  /**
   * Opens a new buffered {@link OutputStream} for writing to this sink. The returned stream is not