.put("two", 2)
            .buildOrThrow();
    CollectorTester.of(collector, equivalence)
        .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3));
  }

  public void testToImmutableSortedMap_withComparator() {
    Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
        toImmutableSortedMap(String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue);

    assertThat(copy).isNotSameInstanceAs(sortedSet);
  }

  public void testToImmutableSet() {
    Collector<String, ?, ImmutableSet<String>> collector = toImmutableSet();
    Equivalence<ImmutableSet<String>> equivalence =
        Equivalence.equals().onResultOf(ImmutableSet::asList);
    CollectorTester.of(collector, equivalence)
        .expectCollects(ImmutableSet.of("a", "b", "c", "d"), "a", "b", "a", "c", "b", "b", "d");
  }

    return max(10L, Runtime.getRuntime().totalMemory() / (32L * 1024L * 1024L));
  }

  /**
   * Waits until the given future {@linkplain Future#isDone is done}, invoking the garbage collector
   * as necessary to try to ensure that this will happen.
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  @SuppressWarnings("removal") // b/487687332

        new LineProcessor<List<String>>() {
          final List<String> collector = new ArrayList<>();

          @Override
          public boolean processLine(String line) {
            collector.add(whitespace().trimFrom(line));
            return true;
          }

          @Override
          public List<String> getResult() {
            return collector;
          }
        };

    return max(10L, Runtime.getRuntime().totalMemory() / (32L * 1024L * 1024L));
  }

  /**
   * Waits until the given future {@linkplain Future#isDone is done}, invoking the garbage collector
   * as necessary to try to ensure that this will happen.
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  @SuppressWarnings("removal") // b/487687332

        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()

    checkArgument(fpp < 1.0, "False positive probability (%s) must be < 1.0", fpp);
    return Collector.of(
        () -> BloomFilter.create(funnel, expectedInsertions, fpp),
        BloomFilter::put,
        (bf1, bf2) -> {
          bf1.putAll(bf2);
          return bf1;
        },
        Collector.Characteristics.UNORDERED,
        Collector.Characteristics.CONCURRENT);
  }

  /**

        NullPointerException.class,
        () -> ImmutableSetMultimap.copyOf((Multimap<String, Integer>) input));
  }

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

        new LineProcessor<List<String>>() {
          final List<String> collector = new ArrayList<>();

          @Override
          public boolean processLine(String line) {
            collector.add(whitespace().trimFrom(line));
            return true;
          }

          @Override
          public List<String> getResult() {
            return collector;
          }
        };

   * <p>If multiple input elements map to the same row and column, the specified merging function is
   * used to combine the values. Like {@link
   * java.util.stream.Collectors#toMap(java.util.function.Function, java.util.function.Function,
   * BinaryOperator, java.util.function.Supplier)}, this Collector throws a {@code
   * NullPointerException} on null values returned from {@code valueFunction}, and treats nulls