if (elementStack.contains(element)) {
                while (!elementStack.getFirst().equals(element)) {
                    visitor.onEndHtmlElement(elementStack.removeFirst());
                }
                elementStack.removeFirst();
                visitor.onEndHtmlElement(element);
            }
        }

        private void unwindTo(Collection<String> ancestors, TokenVisitor visitor) {

  fun enqueueRequestCookies(vararg cookies: Cookie) {
    requestCookies.add(cookies.toList())
  }

  fun takeResponseCookies(): List<Cookie> = responseCookies.removeFirst()

  fun assertResponseCookies(vararg cookies: String?) {
    assertThat(takeResponseCookies().map(Cookie::toString)).containsExactly(*cookies)
  }

  override fun saveFromResponse(
    url: HttpUrl,

  }

  @Override
  public void push(@ParametricNullness E e) {
    delegate().push(e);
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public E removeFirst() {
    return delegate().removeFirst();
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public E removeLast() {
    return delegate().removeLast();
  }

  @CanIgnoreReturnValue

    @Override
    public boolean offerLast(E e) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.offerLast(e);
    }

    @Override
    public E removeFirst() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.removeFirst();
    }

    @Override
    public E removeLast() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.removeLast();
    }

    @Override

    @Override
    public boolean offerLast(E e) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.offerLast(e);
    }

    @Override
    public E removeFirst() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.removeFirst();
    }

    @Override
    public E removeLast() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.removeLast();
    }

    @Override

        }
    }

    public void push(Element element) {
        stack.getFirst().appendChild(element);
        stack.addFirst(element);
    }

    public Element pop() {
        Element element = stack.removeFirst();
        if (emptyPara(element)) {
            element.getParentNode().removeChild(element);
        }
        return element;
    }

    private boolean emptyPara(Element element) {

    }

    @Override
    public void start(String context) {
        contextStack.addFirst(context);
    }

    @Override
    public void finish() {
        contextStack.removeFirst();
    }

    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemoveFirst() throws Exception {
        list.addLast("1");
        list.addLast("2");
        list.removeFirst();
        assertThat(list.getFirst(), is("2"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemoveLast() throws Exception {
        list.addLast("1");

    private final Deque<Runnable> tasks = new ArrayDeque<>();

    @Override
    public void execute(Runnable task) {
      tasks.add(task);
    }

    private void runNext() {
      tasks.removeFirst().run();
    }
  }

  public void testAsyncReload() throws Exception {
    AtomicInteger loadCount = new AtomicInteger();
    AtomicInteger reloadCount = new AtomicInteger();

    seen.add(rootVariant)
    queue.addAll(rootDependencies)

    while (queue.isNotEmpty()) {
        val dependency = when (val result = queue.removeFirst()) {
            is ResolvedDependencyResult -> result
            is UnresolvedDependencyResult -> throw result.failure
            else -> throw AssertionError("Unknown dependency type: $result")
        }