return this;
    }

    @Override
    public List<ArtifactRepository> getRemoteRepositories() {
        if (remoteRepositories == null) {
            remoteRepositories = new ArrayList<>();
        }

        return remoteRepositories;
    }

    @Override
    public DefaultRepositoryRequest setRemoteRepositories(List<ArtifactRepository> remoteRepositories) {

import com.google.common.collect.testing.features.CollectionSize;
import com.google.common.collect.testing.features.MapFeature;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
import org.junit.Ignore;

/**
 * Tester for {@link Multimap#put}.
 *
 * @author Louis Wasserman

      List<Double> xValues, List<Double> yValues, int partitionSize) {
    checkArgument(xValues.size() == yValues.size());
    checkArgument(partitionSize > 0);
    PairedStatsAccumulator accumulator = new PairedStatsAccumulator();
    List<List<Double>> xPartitions = Lists.partition(xValues, partitionSize);
    List<List<Double>> yPartitions = Lists.partition(yValues, partitionSize);

  @CollectionSize.Require(absent = ZERO)
  public void testPutDuplicateValue() {
    List<Entry<K, V>> entries = copyToList(multimap().entries());

    for (Entry<K, V> entry : entries) {
      resetContainer();

      K k = entry.getKey();
      V v = entry.getValue();

      List<V> values = multimap().get(k);
      List<V> expectedValues = copyToList(values);

      assertTrue(multimap().put(k, v));

import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;

import org.apache.maven.project.DependencyResolutionResult;
import org.apache.maven.project.MavenProject;

public class DefaultMavenExecutionResult implements MavenExecutionResult {
    private MavenProject project;

    private List<MavenProject> topologicallySortedProjects = Collections.emptyList();

    val dispatcher: Dispatcher = client.dispatcher
    val proxy: Proxy? = client.proxy
    val protocols: List<Protocol> = client.protocols
    val connectionSpecs: List<ConnectionSpec> = client.connectionSpecs
    val interceptors: List<Interceptor> = client.interceptors
    val networkInterceptors: List<Interceptor> = client.networkInterceptors
    val eventListenerFactory: EventListener.Factory = client.eventListenerFactory

    @app.post("/items/", responses={402: {"model": Item}})
    def create_item(item: Item) -> Item:
        return item

    @app.post("/items-list/")
    def create_item_list(item: list[Item]):
        return item

    @app.get("/items/")
    def read_items() -> list[Item]:
        return [
            Item(
                name="Portal Gun",
                description="Device to travel through the multi-rick-verse",

        } else {
            paramMap.put(Client.USER_AGENT, userAgent);
        }

        final List<WebAuthentication> webAuthList = webAuthenticationService.getWebAuthenticationList(getId());
        final List<Authentication> basicAuthList = new ArrayList<>();
        for (final WebAuthentication webAuth : webAuthList) {
            basicAuthList.add(webAuth.getAuthentication());

      return (Entry<String, Integer>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<String, Integer>> order(List<Entry<String, Integer>> insertionOrder) {
      return insertionOrder;
    }

    @Override
    public List<Entry<String, Integer>> create(Object... elements) {
      ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
      for (Object o : elements) {

     *
     * @param <T> The type of objects to insert.
     * @param list The list of objects to insert.
     * @param opType The operation type (CREATE, INDEX, etc.).
     * @throws OpenSearchAccessException if the bulk insertion fails.
     */
    protected <T> void insertAll(final List<T> list, final OpType opType) {
        insertAll(list, opType, false);
    }

    /**