delegate.clear();
    }

    @Override
    public Object[] toArray() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.toArray();
    }

    @Override
    public <T> T[] toArray(T[] array) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.toArray(array);
    }

    private static final long serialVersionUID = 0;
  }

  }

  @Override
  public boolean isEmpty() {
    return delegate.isEmpty();
  }

  @Override
  public Object[] toArray() {
    return delegate.toArray();
  }

  @Override
  public <T extends @Nullable Object> T[] toArray(T[] other) {
    return delegate.toArray(other);
  }

  @Override
  public String toString() {
    return delegate.toString();
  }

    // Depending on JDK version, either toArray() or toArray(T[]) may be called... use this class
    // rather than mocking to ensure that one of those methods is called.
    class TestArrayList<E> extends ArrayList<E> {
      boolean toArrayCalled = false;

      @Override
      public Object[] toArray() {
        toArrayCalled = true;
        return super.toArray();
      }

      @Override

    assertThat(Shorts.toArray(bytes)).isEqualTo(array);
    assertThat(Shorts.toArray(shorts)).isEqualTo(array);
    assertThat(Shorts.toArray(ints)).isEqualTo(array);
    assertThat(Shorts.toArray(floats)).isEqualTo(array);
    assertThat(Shorts.toArray(longs)).isEqualTo(array);
    assertThat(Shorts.toArray(doubles)).isEqualTo(array);
  }

    assertThat(Floats.toArray(bytes)).isEqualTo(array);
    assertThat(Floats.toArray(shorts)).isEqualTo(array);
    assertThat(Floats.toArray(ints)).isEqualTo(array);
    assertThat(Floats.toArray(floats)).isEqualTo(array);
    assertThat(Floats.toArray(longs)).isEqualTo(array);
    assertThat(Floats.toArray(doubles)).isEqualTo(array);
  }

    return new SafeTreeSet<>(delegate.tailSet(checkValid(fromElement), inclusive));
  }

  @Override
  public Object[] toArray() {
    return delegate.toArray();
  }

  @Override
  public <T> T[] toArray(T[] a) {
    return delegate.toArray(a);
  }

  @CanIgnoreReturnValue
  private <T> T checkValid(T t) {
    // a ClassCastException is what's supposed to happen!

        .testEquals();
  }

  public void testEqualsFalse() {
    List<Entry<K, V>> targetEntries = new ArrayList<>(getSampleElements());
    targetEntries.add(Helpers.mapEntry(k0(), v3()));
    new EqualsTester()
        .addEqualityGroup(multimap())
        .addEqualityGroup(getSubjectGenerator().create(targetEntries.toArray()))
        .testEquals();
  }

  public void testToArray_noArg() {
    Object[] actual = getList().toArray();
    assertArrayEquals("toArray() order should match list", createOrderedArray(), actual);
  }

  @CollectionSize.Require(absent = ZERO)
  public void testToArray_tooSmall() {
    Object[] actual = getList().toArray(new Object[0]);
    assertArrayEquals("toArray(tooSmall) order should match list", createOrderedArray(), actual);
  }

    assertThat(Booleans.toArray(none)).isEqualTo(EMPTY);

    List<Boolean> one = Arrays.asList(false);
    assertThat(Booleans.toArray(one)).isEqualTo(ARRAY_FALSE);

    boolean[] array = {false, false, true};

    List<Boolean> three = Arrays.asList(false, false, true);
    assertThat(Booleans.toArray(three)).isEqualTo(array);

    assertThat(Booleans.toArray(Booleans.asList(array))).isEqualTo(array);
  }

      this.upperBounds = JavaVersion.CURRENT.usedInGenericType(upperBounds);
    }

    @Override
    public Type[] getLowerBounds() {
      return toArray(lowerBounds);
    }

    @Override
    public Type[] getUpperBounds() {
      return toArray(upperBounds);
    }

    @Override
    public boolean equals(@CheckForNull Object obj) {
      if (obj instanceof WildcardType) {