* @throws Exception
     */
    @Test
    public void testGetLast() throws Exception {
        try {
            list.getLast();
            fail();
        } catch (final NoSuchElementException ex) {
            System.out.println(ex);
        }
        list.addLast("1");
        assertThat(list.getLast(), is("1"));
    }

    /**
     * @throws Exception
     */
    @Test

  }

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

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

  @CanIgnoreReturnValue // TODO(cpovirk): Consider removing this?
  @Override
  public boolean offerFirst(@ParametricNullness E e) {
    return delegate().offerFirst(e);
  }

    }

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

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

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

    }

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

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

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

    }

    @Override
    public boolean hasNext() {
      return !stack.isEmpty();
    }

    @Override
    public T next() {
      Iterator<T> itr = stack.getLast(); // throws NSEE if empty
      T result = checkNotNull(itr.next());
      if (!itr.hasNext()) {
        stack.removeLast();
      }
      Iterator<T> childItr = children(result).iterator();

    }

    @Override
    public boolean hasNext() {
      return !stack.isEmpty();
    }

    @Override
    public T next() {
      Iterator<T> itr = stack.getLast(); // throws NSEE if empty
      T result = checkNotNull(itr.next());
      if (!itr.hasNext()) {
        stack.removeLast();
      }
      Iterator<T> childItr = children(result).iterator();

        "addAll(n, allPresent) should return true",
        getList().addAll(0, MinimalCollection.of(e0())));
    expectAdded(0, e0());
  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAllAtIndex_unsupportedAllPresent() {
    assertThrows(
        UnsupportedOperationException.class, () -> getList().addAll(0, MinimalCollection.of(e0())));
    expectUnchanged();
  }

   */
  public void testAddAtIndex_unsupportedPresent() {
    assertThrows(UnsupportedOperationException.class, () -> getList().add(0, e0()));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  public void testAddAtIndex_supportedNotPresent() {
    getList().add(0, e3());
    expectAdded(0, e3());
  }

  @CollectionFeature.Require(FAILS_FAST_ON_CONCURRENT_MODIFICATION)

    assertEquals("::1", HostAndPort.fromString("[::1]:80").requireBracketsForIPv6().getHost());
    // Non-bracketed non-IPv6 works fine.
    assertEquals("x", HostAndPort.fromString("x").requireBracketsForIPv6().getHost());
    assertEquals("x", HostAndPort.fromString("x:80").requireBracketsForIPv6().getHost());

    // Non-bracketed IPv6 fails.
    assertThrows(

  public void testRemoveAtIndex_unsupported() {
    assertThrows(UnsupportedOperationException.class, () -> getList().remove(0));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
  public void testRemoveAtIndex_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().remove(-1));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)