(ms1, ms2) -> ms1.equals(ms2) && ms1.entrySet().asList().equals(ms2.entrySet().asList());
    CollectorTester.of(ImmutableMultiset.<String>toImmutableMultiset(), equivalence)
        .expectCollects(ImmutableMultiset.of())
        .expectCollects(
            ImmutableMultiset.of("a", "a", "b", "c", "c", "c"), "a", "a", "b", "c", "c", "c");
  }

  public void testToImmutableMultisetCountFunction() {

        toImmutableTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue);
    CollectorTester.of(collector)
        .expectCollects(ImmutableTable.of())
        .expectCollects(ImmutableTable.of("one", "uno", 1), immutableCell("one", "uno", 1));
  }

  public void testToImmutableTableMergingSanityTest() {

            ImmutableSortedMultiset.<String>toImmutableSortedMultiset(
                String.CASE_INSENSITIVE_ORDER),
            equivalence)
        .expectCollects(ImmutableSortedMultiset.emptyMultiset(String.CASE_INSENSITIVE_ORDER))
        .expectCollects(
            ImmutableSortedMultiset.orderedBy(String.CASE_INSENSITIVE_ORDER)
                .addCopies("a", 2)
                .addCopies("b", 1)

            .onResultOf((ImmutableListMultimap<?, ?> mm) -> mm.asMap().entrySet().asList())
            .and(Equivalence.equals());
    CollectorTester.of(collector, equivalence)
        .expectCollects(ImmutableListMultimap.of())
        .expectCollects(
            ImmutableListMultimap.of("a", 1, "b", 2, "a", 3, "c", 4),
            mapEntry("a", 1),
            mapEntry("b", 2),
            mapEntry("a", 3),

    CollectorTester.of(
            ImmutableRangeMap.<Range<Integer>, Integer, Integer>toImmutableRangeMap(
                k -> k, k -> k.lowerEndpoint()))
        .expectCollects(rangeMap, rangeOne, rangeTwo);
  }

    Equivalence<ImmutableMap<String, Integer>> equivalence =
        Equivalence.equals().<Entry<String, Integer>>pairwise().onResultOf(ImmutableMap::entrySet);
    CollectorTester.of(collector, equivalence)
        .expectCollects(
            ImmutableMap.of("one", 1, "two", 2, "three", 3),
            mapEntry("one", 1),
            mapEntry("two", 2),
            mapEntry("three", 3));
  }

            .and(Equivalence.equals().onResultOf(ImmutableSortedSet::asList))
            .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() {

        Equivalence.equals()
            .<Entry<String, Integer>>pairwise()
            .onResultOf(ImmutableBiMap::entrySet);
    CollectorTester.of(collector, equivalence)
        .expectCollects(
            ImmutableBiMap.of("one", 1, "two", 2, "three", 3),
            mapEntry("one", 1),
            mapEntry("two", 2),
            mapEntry("three", 3));
  }

        () -> ImmutableList.sortedCopyOf(String.CASE_INSENSITIVE_ORDER, (Collection<String>) c));
  }

  public void testToImmutableList() {
    CollectorTester.of(ImmutableList.<String>toImmutableList())
        .expectCollects(ImmutableList.of("a", "b", "c", "d"), "a", "b", "c", "d");
  }

  // Basic tests

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester
  public void testNullPointers() {