* @deprecated use {@link #MultipleArtifactsNotFoundException(Artifact, List, List, List)}
     */
    @Deprecated
    public MultipleArtifactsNotFoundException(
            Artifact originatingArtifact,
            List<Artifact> missingArtifacts,
            List<ArtifactRepository> remoteRepositories) {
        this(originatingArtifact, new ArrayList<>(), missingArtifacts, remoteRepositories);

    resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k0(), v0()));

    List<V> list = multimap().get(k0());
    multimap().remove(k0(), v0());
    assertContentsInOrder(list, v1(), v0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(SEVERAL)
  public void testRemoveAtIndexFromGetPropagates() {
    List<V> values = asList(v0(), v1(), v0());

    for (int i = 0; i < 3; i++) {

        final List<Map<String, Object>> itemList = JsonPath.from(response).getList(getResponsePath(namePrefix));
        assertEquals(1, itemList.size());
        return itemList.get(0);
    }

    protected static List<String> getSchedulerIds(final String namePrefix) {
        final String response = getJsonResponse("/api/admin/scheduler/settings");

    }

    protected Map<String, List<Tuple3<String, QueryBuilder, ScoreFunctionBuilder<?>>>> getQueryMap(final String key) {
        final Map<String, List<Tuple3<String, QueryBuilder, ScoreFunctionBuilder<?>>>> map = keyMatchQueryMap.get(key);
        if (map != null) {
            return map;
        }
        return Collections.emptyMap();
    }

    private Artifact artifact;

    private List<ResolutionNode> children;

    private final List<Object> parents;

    private final int depth;

    private final ResolutionNode parent;

    private final List<ArtifactRepository> remoteRepositories;

    private boolean active = true;

    private List<Artifact> trail;

    public ResolutionNode(Artifact artifact, List<ArtifactRepository> remoteRepositories) {

    private final ImmutableList<E> list;

    Itr(ImmutableList<E> list, int index) {
      super(list.size(), index);
      this.list = list;
    }

    @Override
    protected E get(int index) {
      return list.get(index);
    }
  }

  @Override
  public int indexOf(@CheckForNull Object object) {
    return (object == null) ? -1 : Lists.indexOfImpl(this, object);
  }

  private final Object lock = new Object();

  /** We will keep a private list of all logged records */
  @GuardedBy("lock")
  private final List<LogRecord> list = new ArrayList<>();

  /** Adds the most recently logged record to our list. */
  @Override
  public void publish(@Nullable LogRecord record) {
    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }
    }
  }

  @Override

            list.add(entity);
        });

        list.setPageSize(size);
        list.setAllRecordCount((int) searchHits.getTotalHits().value);
        list.setCurrentPageNumber(cb.getFetchPageNumber());

        list.setTook(response.getTook().getMillis());
        list.setTotalShards(response.getTotalShards());
        list.setSuccessfulShards(response.getSuccessfulShards());

        final CsvWriter csvWriter = new CsvWriter(writer, cfg);
        try {
            final List<String> list = new ArrayList<>();
            list.add("SessionId");
            list.add("SessionCreatedTime");
            list.add("Key");
            list.add("Value");
            list.add("CreatedTime");
            csvWriter.writeValues(list);

        .testForwarding(
            List.class,
            new Function<List, List>() {
              @Override
              public List apply(List delegate) {
                return wrap(delegate);
              }
            });
  }

  public void testEquals() {
    List<String> list1 = ImmutableList.of("one");
    List<String> list2 = ImmutableList.of("two");
    new EqualsTester()