*/
    @Override
    protected void removeRange(int fromIndex, int toIndex) {
      fromList.subList(fromIndex, toIndex).clear();
    }

    @Override
    public int size() {
      return fromList.size();
    }

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

    @Override
    public ListIterator<T> listIterator(int index) {

  }

  @Override
  public E get(int index) {
    Preconditions.checkElementIndex(index, 1);
    return element;
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return singletonIterator(element);
  }

  @Override
  public Spliterator<E> spliterator() {
    return singleton(element).spliterator();
  }

  @Override
  public int size() {
    return 1;
  }

  @Override
  protected Map<Integer, UnhashableObject> makeEmptyMap() {
    return ImmutableMap.of();
  }

  @Override
  protected Map<Integer, UnhashableObject> makePopulatedMap() {
    Unhashables unhashables = new Unhashables();
    return ImmutableMap.of(0, unhashables.e0(), 1, unhashables.e1(), 2, unhashables.e2());
  }

  @Override
  protected Integer getKeyNotInPopulatedMap() {

    private static final String KEY_PROPERTY = "";

    @Override
    protected String getNamePrefix() {
        return NAME_PREFIX;
    }

    @Override
    protected String getApiPath() {
        return API_PATH;
    }

    @Override
    protected String getKeyProperty() {
        return KEY_PROPERTY;
    }

    @Override
    protected String getListEndpointSuffix() {

    }
    return null;
  }

  @Override
  public Annotation[] getAnnotations() {
    return getDeclaredAnnotations();
  }

  /**
   * @since 18.0
   */
  @Override
  public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType) {
    return getDeclaredAnnotationsByType(annotationType);
  }

  /**
   * @since 18.0
   */
  @Override
  public Annotation[] getDeclaredAnnotations() {

    ListMultimapTestSuiteBuilder<K, V> result = new ListMultimapTestSuiteBuilder<>();
    result.usingGenerator(generator);
    return result;
  }

  @SuppressWarnings("rawtypes") // class literals
  @Override
  protected List<Class<? extends AbstractTester>> getTesters() {
    List<Class<? extends AbstractTester>> testers = copyToList(super.getTesters());
    testers.add(ListMultimapAsMapTester.class);

            return null;
          }

          @Override
          boolean isDone() {
            return false;
          }

          @Override
          String toPendingString() {
            return "";
          }

          @Override
          void afterRanInterruptiblySuccess(@Nullable Void result) {}

          @Override
          void afterRanInterruptiblyFailure(Throwable error) {}

            return null;
          }

          @Override
          boolean isDone() {
            return false;
          }

          @Override
          String toPendingString() {
            return "";
          }

          @Override
          void afterRanInterruptiblySuccess(@Nullable Void result) {}

          @Override
          void afterRanInterruptiblyFailure(Throwable error) {}

    private volatile boolean shutdown;

    @Override
    public void shutdown() {
      shutdown = true;
    }

    @Override
    public List<Runnable> shutdownNow() {
      shutdown();
      return ImmutableList.of();
    }

    @Override
    public boolean isShutdown() {
      return shutdown;
    }

    @Override
    public boolean isTerminated() {
      return shutdown;

    final List<Object> differentlyOverriddenAnnotatedInSubclassGoodEvents = new ArrayList<>();

    @Override
    public void overriddenNotAnnotatedInSubclass(Object o) {
      super.overriddenNotAnnotatedInSubclass(o);
    }

    @Subscribe
    @Override
    // We are testing how we treat an override with the same behavior and annotations.
    @SuppressWarnings("RedundantOverride")