multimap.put("a", -3);
    multimap.put("z", -2);
    return multimap;
  }

  @Override
  protected Map<String, Collection<Integer>> makeEmptyMap() {
    return createMultimap().asMap().subMap("e", "p");
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    TreeMultimap<String, Integer> multimap = createMultimap();
    multimap.put("f", 1);
    multimap.put("f", 2);

            private final RemoteRepository repository;
            private final Collection<ProducedArtifact> artifacts;
            private final int retryFailedDeploymentCount;

            DefaultArtifactDeployerRequest(
                    @Nonnull Session session,
                    @Nonnull RemoteRepository repository,
                    @Nonnull Collection<ProducedArtifact> artifacts,
                    int retryFailedDeploymentCount) {

  }

  @Override
  public boolean add(E element) {
    return delegate.add(checkValid(element));
  }

  @Override
  public boolean addAll(Collection<? extends E> collection) {
    for (E e : collection) {
      checkValid(e);
    }
    return delegate.addAll(collection);
  }

  @Override
  public @Nullable E ceiling(E e) {
    return delegate.ceiling(checkValid(e));
  }

  @Override
  public void clear() {

      Entry<?, ?> entry = (Entry<?, ?>) element;
      element = mapEntry(entry.getKey(), entry.getValue());
    }
    assertTrue(collection.contains(element)); // sanity check
    iterator.remove();
    assertFalse(collection.contains(element));
    assertEquals(originalSize - 1, collection.size());
  }

  @CollectionFeature.Require({KNOWN_ORDER, SUPPORTS_ITERATOR_REMOVE})
  public void testIterator_knownOrderRemoveSupported() {

  }

  public void testCopyOf_collectionContainingNull() {
    Collection<@Nullable String> c = MinimalCollection.of("a", null, "b");
    assertThrows(NullPointerException.class, () -> copyOf((Collection<String>) c));
  }

  enum TestEnum {
    A,
    B,
    C,
    D
  }

  public void testCopyOf_collection_enumSet() {
    Collection<TestEnum> c = EnumSet.of(TestEnum.A, TestEnum.B, TestEnum.D);

      K key, V value) {
    return singletonMap(key, value).entrySet().iterator().next();
  }

  private static boolean isEmpty(Iterable<?> iterable) {
    return iterable instanceof Collection
        ? ((Collection<?>) iterable).isEmpty()
        : !iterable.iterator().hasNext();
  }

  public static void assertEmpty(Iterable<?> iterable) {
    if (!isEmpty(iterable)) {

import com.google.common.collect.Multimap;
import com.google.common.collect.testing.features.CollectionSize;
import com.google.common.collect.testing.features.MapFeature;
import java.util.Collection;
import java.util.Map.Entry;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.junit.Ignore;

/**
 * Tester for the {@code size} methods of {@code Multimap} and its views.
 *

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.tests;


import static org.junit.Assert.assertEquals;

import java.io.IOException;
import java.util.Collection;
import java.util.Map;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

import jcifs.smb.SID;


/**

 * under the License.
 */
package org.apache.maven.repository.internal;

import java.io.File;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.LinkedHashSet;

import org.apache.maven.artifact.repository.metadata.Metadata;
import org.apache.maven.artifact.repository.metadata.Versioning;

                return super.add(element);
              }

              @Override
              public boolean addAll(Collection<? extends Integer> collection) {
                return standardAddAll(collection);
              }
            };
          }
        };

    Map<Color, Collection<Integer>> map = Maps.newEnumMap(Color.class);
    Multimap<Color, Integer> multimap = Multimaps.newMultimap(map, factory);