public ForMapMultimapAsMapImplementsMapTest() {
    super(true, true, true);
  }

  @Override
  protected Map<String, Collection<Integer>> makeEmptyMap() {
    Map<String, Integer> map = new HashMap<>();
    return Multimaps.forMap(map).asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    Map<String, Integer> map = new HashMap<>();
    map.put("foo", 1);

    extends ForwardingMultimap<K, V> implements ListMultimap<K, V> {

  /** Constructor for use by subclasses. */
  protected ForwardingListMultimap() {}

  @Override
  protected abstract ListMultimap<K, V> delegate();

  @Override
  public List<V> get(@ParametricNullness K key) {
    return delegate().get(key);
  }

  @CanIgnoreReturnValue
  @Override

        K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingSetMultimap<K, V> implements SortedSetMultimap<K, V> {

  /** Constructor for use by subclasses. */
  protected ForwardingSortedSetMultimap() {}

  @Override
  protected abstract SortedSetMultimap<K, V> delegate();

  @Override
  public SortedSet<V> get(@ParametricNullness K key) {
    return delegate().get(key);
  }

  @Override

/**
 * Utility class for annotations.
 *
 * @author higa
 */
public abstract class AnnotationUtil {

    /**
     * Do not instantiate.
     */
    protected AnnotationUtil() {
    }

    /**
     * Returns the elements of the annotation as a {@link Map} of names and values.
     *
     * @param annotation the annotation (must not be {@literal null})

import org.apache.maven.artifact.repository.ArtifactRepository;

/**
 */
public class ArtifactNotFoundException extends AbstractArtifactResolutionException {
    private String downloadUrl;

    protected ArtifactNotFoundException(
            String message, Artifact artifact, List<ArtifactRepository> remoteRepositories) {
        super(message, artifact, remoteRepositories);
    }

                dominant.add(recessiveModel);
            } else {
                mergeToolchainModelConfiguration(dominantModel, recessiveModel);
            }
        }
    }

    protected void mergeToolchainModelConfiguration(ToolchainModel target, ToolchainModel source) {
        Xpp3Dom src = (Xpp3Dom) source.getConfiguration();
        if (src != null) {

   * the directionality of this graph.
   */
  protected final void validateEndpoints(EndpointPair<?> endpoints) {
    checkNotNull(endpoints);
    checkArgument(isOrderingCompatible(endpoints), ENDPOINTS_MISMATCH);
  }

  protected final boolean isOrderingCompatible(EndpointPair<?> endpoints) {
    return endpoints.isOrdered() == this.isDirected();
  }

   * consistent.
   */
  private volatile StateSnapshot snapshot = new StateSnapshot(NEW);

  /** Constructor for use by subclasses. */
  protected AbstractService() {}

  /**
   * This method is called by {@link #startAsync} to initiate service startup. The invocation of
   * this method should cause a call to {@link #notifyStarted()}, either during this method's run,

    assertTrue(future.isCancelled());
  }

  private class NullService extends AbstractScheduledService {
    @Override
    protected void runOneIteration() throws Exception {}

    @Override
    protected Scheduler scheduler() {
      return configuration;
    }

    @Override
    protected ScheduledExecutorService executor() {
      return executor;
    }
  }

    assertTrue(future.isCancelled());
  }

  private class NullService extends AbstractScheduledService {
    @Override
    protected void runOneIteration() throws Exception {}

    @Override
    protected Scheduler scheduler() {
      return configuration;
    }

    @Override
    protected ScheduledExecutorService executor() {
      return executor;
    }
  }