Collector<Entry<String, Integer>, ?, ImmutableMap<String, Integer>> collector =
        toImmutableMap(Entry::getKey, Entry::getValue);
    assertThrows(
        IllegalArgumentException.class,
        () -> Stream.of(mapEntry("one", 1), mapEntry("one", 11)).collect(collector));
  }

  public void testToImmutableMapMerging() {

        private final OutputStream collector;


        public CacheStream ( OutputStream stream, OutputStream collector ) {
            this.stream = stream;
            this.collector = collector;
        }


        @Override
        public void close () throws IOException {
            this.stream.close();
            this.collector.close();
        }


        @Override

        NullPointerException.class,
        () -> ImmutableListMultimap.copyOf((ArrayListMultimap<String, Integer>) input));
  }

  public void testToImmutableListMultimap() {
    Collector<Entry<String, Integer>, ?, ImmutableListMultimap<String, Integer>> collector =
        toImmutableListMultimap(Entry::getKey, Entry::getValue);
    BiPredicate<ImmutableListMultimap<?, ?>, ImmutableListMultimap<?, ?>> equivalence =
        Equivalence.equals()

            .and(Equivalence.equals());
    CollectorTester.of(collector, equivalence)
        .expectCollects(
            ImmutableSortedSet.of("a", "b", "c", "d"), "a", "b", "a", "c", "b", "b", "d");
  }

  public void testToImmutableSortedSet_customComparator() {
    Collector<String, ?, ImmutableSortedSet<String>> collector =
        toImmutableSortedSet(String.CASE_INSENSITIVE_ORDER);

import org.apache.maven.project.MavenProject;
import org.apache.maven.project.ProjectBuildingException;
import org.apache.maven.project.collector.MultiModuleCollectionStrategy;
import org.apache.maven.project.collector.PomlessCollectionStrategy;
import org.apache.maven.project.collector.RequestPomCollectionStrategy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static java.util.Comparator.comparing;

/**

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.stream.Collector;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**

  @IgnoreJRERequirement // Users will use this only if they're already using streams.
  public static <E> Collector<E, ?, ImmutableSortedMultiset<E>> toImmutableSortedMultiset(
      Comparator<? super E> comparator) {
    return toImmutableSortedMultiset(comparator, Function.identity(), e -> 1);
  }

  /**
   * Returns a {@code Collector} that accumulates elements into an {@code ImmutableSortedMultiset}

      Collector<SomeEnum, A, ImmutableSet<SomeEnum>> collector) {
    A accumulator = collector.supplier().get();
    BiConsumer<A, SomeEnum> adder = collector.accumulator();
    adder.accept(accumulator, SomeEnum.A);
    adder.accept(accumulator, SomeEnum.B);
    ImmutableSet<SomeEnum> set = collector.finisher().apply(accumulator);

import static java.util.Collections.unmodifiableList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.Lists;
import com.google.errorprone.annotations.concurrent.LazyInit;
import com.google.j2objc.annotations.RetainedLocalRef;
import java.util.Collections;
import java.util.List;
import javax.annotation.CheckForNull;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.RandomAccess;
import java.util.stream.Collector;
import jsinterop.annotations.JsMethod;
import org.checkerframework.checker.nullness.qual.Nullable;

/**