/**
 * Tests for {@code ForwardingSortedMap}.
 *
 * @author Robert KonigsbergSortedMapFeature
 */
@NullUnmarked
public class ForwardingSortedMapTest extends TestCase {
  static class StandardImplForwardingSortedMap<K, V> extends ForwardingSortedMap<K, V> {
    private final SortedMap<K, V> backingSortedMap;

    StandardImplForwardingSortedMap(SortedMap<K, V> backingSortedMap) {

     * @return <code>to</code> collection
     */
    public static <T extends Collection<Artifact>> T copyArtifacts(Collection<Artifact> from, T to) {
        for (Artifact artifact : from) {
            to.add(ArtifactUtils.copyArtifact(artifact));
        }
        return to;
    }

    public static <K, T extends Map<K, Artifact>> T copyArtifacts(Map<K, ? extends Artifact> from, T to) {
        if (from != null) {

@NullMarked
public interface TestMultimapGenerator<
        K extends @Nullable Object, V extends @Nullable Object, M extends Multimap<K, V>>
    extends TestContainerGenerator<M, Entry<K, V>> {

  K[] createKeyArray(int length);

  V[] createValueArray(int length);

  SampleElements<K> sampleKeys();

  SampleElements<V> sampleValues();

  Collection<V> createCollection(Iterable<? extends V> values);

@NullMarked
public interface TestMultimapGenerator<
        K extends @Nullable Object, V extends @Nullable Object, M extends Multimap<K, V>>
    extends TestContainerGenerator<M, Entry<K, V>> {

  K[] createKeyArray(int length);

  V[] createValueArray(int length);

  SampleElements<K> sampleKeys();

  SampleElements<V> sampleValues();

  Collection<V> createCollection(Iterable<? extends V> values);

 *
 * @author Sven Mawson
 * @since 1.0
 */
@GwtIncompatible
public class ListenableFutureTask<V extends @Nullable Object> extends FutureTask<V>
    implements ListenableFuture<V> {
  // TODO(cpovirk): explore ways of making ListenableFutureTask final. There are some valid reasons
  // such as BoundedQueueExecutorService to allow extends but it would be nice to make it final to
  // avoid unintended usage.

 *
 * @author Jared Levy
 */
@GwtCompatible
class StandardTable<R, C, V> extends AbstractTable<R, C, V> implements Serializable {
  final Map<R, Map<C, V>> backingMap;
  final Supplier<? extends Map<C, V>> factory;

  StandardTable(Map<R, Map<C, V>> backingMap, Supplier<? extends Map<C, V>> factory) {
    this.backingMap = backingMap;
    this.factory = factory;
  }

  // Accessors

     * @since 19.0
     */
    @CanIgnoreReturnValue
    public Builder<K, V> putAll(Iterable<? extends Entry<? extends K, ? extends V>> entries) {
      if (entries instanceof Collection) {
        ensureCapacity(size + ((Collection<?>) entries).size());
      }
      for (Entry<? extends K, ? extends V> entry : entries) {
        put(entry);
      }
      return this;
    }

    /**

    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);
    testers.add(ListMultimapEqualsTester.class);
    testers.add(ListMultimapPutTester.class);

      Class<T> interfaceType, Method method, Function<? super T, ? extends T> wrapperFunction) {
    new InteractionTester<T>(interfaceType, method).testInteraction(wrapperFunction);
  }

  private static <T> void testExceptionPropagation(
      Class<T> interfaceType, Method method, Function<? super T, ? extends T> wrapperFunction) {
    RuntimeException exception = new RuntimeException();
    T proxy =

 * @author Kevin Bourrillion
 * @author Jared Levy
 * @since 2.0
 */
@GwtCompatible
public final class LinkedHashMultiset<E extends @Nullable Object>
    extends AbstractMapBasedMultiset<E> {

  /** Creates a new, empty {@code LinkedHashMultiset} using the default initial capacity. */
  public static <E extends @Nullable Object> LinkedHashMultiset<E> create() {
    return create(ObjectCountHashMap.DEFAULT_SIZE);
  }

  /**