Java 类com.google.common.base.Equivalence 实例源码

项目：googles-monorepo-demo 文件：ImmutableSortedMapTest.java

public void testToImmutableSortedMap() {
  Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
      ImmutableSortedMap.toImmutableSortedMap(
          String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue);
  BiPredicate<ImmutableSortedMap<String, Integer>, ImmutableSortedMap<String, Integer>>
      equivalence =
          Equivalence.equals().onResultOf(ImmutableSortedMap<String, Integer>::comparator)
              .and(Equivalence.equals().onResultOf(map -> map.entrySet().asList()))
              .and(Equivalence.equals());
  ImmutableSortedMap<String, Integer> expected =
      ImmutableSortedMap.<String, Integer>orderedBy(String.CASE_INSENSITIVE_ORDER)
          .put("one", 1)
          .put("three", 3)
          .put("two", 2)
          .build();
  CollectorTester.of(collector, equivalence)
      .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3));
}

项目：googles-monorepo-demo 文件：ImmutableTableTest.java

public void testToImmutableTable() {
  Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> collector =
      ImmutableTable.toImmutableTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue);
  Equivalence<ImmutableTable<String, String, Integer>> equivalence =
      Equivalence.equals()
          .<Cell<String, String, Integer>>pairwise()
          .onResultOf(ImmutableTable::cellSet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          new ImmutableTable.Builder<String, String, Integer>()
              .put("one", "uno", 1)
              .put("two", "dos", 2)
              .put("three", "tres", 3)
              .build(),
          Tables.immutableCell("one", "uno", 1),
          Tables.immutableCell("two", "dos", 2),
          Tables.immutableCell("three", "tres", 3));
}

项目：r8 文件：SimpleClassMerger.java

private <T extends PresortedComparable<T>, S extends KeyedDexItem<T>> void addNonShadowed(
    Iterator<S> items,
    HashMap<Wrapper<T>, S> map,
    Equivalence<T> equivalence,
    Set<Wrapper<T>> existing,
    BiFunction<S, S, S> onConflict) {
  while (items.hasNext()) {
    S item = items.next();
    if (item == null) {
      // This item was filtered out by a preprocessing.
      continue;
    }
    Wrapper<T> wrapped = equivalence.wrap(item.getKey());
    if (existing.contains(wrapped)) {
      S resolved = onConflict.apply(map.get(wrapped), item);
      wrapped = equivalence.wrap(resolved.getKey());
      map.put(wrapped, resolved);
    } else {
      map.put(wrapped, item);
    }
  }
}

项目：googles-monorepo-demo 文件：ConcurrentHashMultisetTest.java

private void testLogicalKeyEquality(
    MapMakerInternalMap.Strength keyStrength) {

  ConcurrentMap<String, AtomicInteger> map =
      new MapMaker().setKeyStrength(keyStrength).keyEquivalence(Equivalence.equals()).makeMap();

  ConcurrentHashMultiset<String> multiset = ConcurrentHashMultiset.create(map);

  String s1 = new String("a");
  String s2 = new String("a");
  assertEquals(s1, s2); // Stating the obvious.

  multiset.add(s1);
  assertTrue(multiset.contains(s1));
  assertTrue(multiset.contains(s2));
  assertEquals(1, multiset.count(s1));
  assertEquals(1, multiset.count(s2));

  multiset.add(s2, 3);
  assertEquals(4, multiset.count(s1));
  assertEquals(4, multiset.count(s2));

  multiset.remove(s1);
  assertEquals(3, multiset.count(s1));
  assertEquals(3, multiset.count(s2));
}

项目：googles-monorepo-demo 文件：MultimapsTest.java

public void testToMultimap() {
  Collector<Entry<String, Integer>, ?, TreeMultimap<String, Integer>> collector =
      Multimaps.toMultimap(Entry::getKey, Entry::getValue, TreeMultimap::create);
  BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
          .and(Equivalence.equals());
  TreeMultimap<String, Integer> empty = TreeMultimap.create();
  TreeMultimap<String, Integer> filled = TreeMultimap.create();
  filled.put("a", 1);
  filled.put("a", 2);
  filled.put("b", 2);
  filled.put("c", 3);
  CollectorTester.of(collector, equivalence)
      .expectCollects(empty)
      .expectCollects(
          filled, mapEntry("a", 1), mapEntry("a", 2), mapEntry("b", 2), mapEntry("c", 3));
}

项目：googles-monorepo-demo 文件：MultimapsTest.java

public void testFlatteningToMultimap() {
  Collector<String, ?, ListMultimap<Character, Character>> collector =
      Multimaps.flatteningToMultimap(
          str -> str.charAt(0),
          str -> str.substring(1).chars().mapToObj(c -> (char) c),
          MultimapBuilder.linkedHashKeys().arrayListValues()::build);
  BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
          .and(Equivalence.equals());
  ListMultimap<Character, Character> empty =
      MultimapBuilder.linkedHashKeys().arrayListValues().build();
  ListMultimap<Character, Character> filled =
      MultimapBuilder.linkedHashKeys().arrayListValues().build();
  filled.putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'));
  filled.putAll('a', Arrays.asList('p', 'p', 'l', 'e'));
  filled.putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'));
  filled.putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'));
  filled.putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'));
  CollectorTester.of(collector, equivalence)
      .expectCollects(empty)
      .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry");
}

项目：googles-monorepo-demo 文件：MapMakerInternalMapTest.java

public void testSetKeyEquivalence() {
  Equivalence<Object> testEquivalence = new Equivalence<Object>() {
    @Override
    protected boolean doEquivalent(Object a, Object b) {
      return false;
    }

    @Override
    protected int doHash(Object t) {
      return 0;
    }
  };

  MapMakerInternalMap<Object, Object, ?, ?> map =
      makeMap(createMapMaker().keyEquivalence(testEquivalence));
  assertSame(testEquivalence, map.keyEquivalence);
  assertSame(map.valueStrength().defaultEquivalence(), map.valueEquivalence());
}

项目：guava-mock 文件：ImmutableListMultimapTest.java

public void testToImmutableListMultimap() {
  Collector<Entry<String, Integer>, ?, ImmutableListMultimap<String, Integer>> collector =
      ImmutableListMultimap.toImmutableListMultimap(Entry::getKey, Entry::getValue);
  BiPredicate<ImmutableListMultimap<?, ?>, ImmutableListMultimap<?, ?>> equivalence =
      Equivalence.equals()
          .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),
          mapEntry("c", 4));
}

项目：guava-mock 文件：ImmutableListMultimapTest.java

public void testFlatteningToImmutableListMultimap() {
  Collector<String, ?, ImmutableListMultimap<Character, Character>> collector =
      ImmutableListMultimap.flatteningToImmutableListMultimap(
          str -> str.charAt(0), str -> str.substring(1).chars().mapToObj(c -> (char) c));
  BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
          .and(Equivalence.equals());
  ImmutableListMultimap<Character, Character> empty = ImmutableListMultimap.of();
  ImmutableListMultimap<Character, Character> filled =
      ImmutableListMultimap.<Character, Character>builder()
          .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
          .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
          .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
          .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
          .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
          .build();
  CollectorTester.of(collector, equivalence)
      .expectCollects(empty)
      .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry");
}

项目：guava-mock 文件：ImmutableTableTest.java

public void testToImmutableTable() {
  Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> collector =
      ImmutableTable.toImmutableTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue);
  Equivalence<ImmutableTable<String, String, Integer>> equivalence =
      Equivalence.equals()
          .<Cell<String, String, Integer>>pairwise()
          .onResultOf(ImmutableTable::cellSet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          new ImmutableTable.Builder<String, String, Integer>()
              .put("one", "uno", 1)
              .put("two", "dos", 2)
              .put("three", "tres", 3)
              .build(),
          Tables.immutableCell("one", "uno", 1),
          Tables.immutableCell("two", "dos", 2),
          Tables.immutableCell("three", "tres", 3));
}

项目：guava-mock 文件：ImmutableTableTest.java

public void testToImmutableTableMerging() {
  Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> collector =
      ImmutableTable.toImmutableTable(
          Cell::getRowKey, Cell::getColumnKey, Cell::getValue, Integer::sum);
  Equivalence<ImmutableTable<String, String, Integer>> equivalence =
      Equivalence.equals()
          .<Cell<String, String, Integer>>pairwise()
          .onResultOf(ImmutableTable::cellSet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          new ImmutableTable.Builder<String, String, Integer>()
              .put("one", "uno", 1)
              .put("two", "dos", 6)
              .put("three", "tres", 3)
              .build(),
          Tables.immutableCell("one", "uno", 1),
          Tables.immutableCell("two", "dos", 2),
          Tables.immutableCell("three", "tres", 3),
          Tables.immutableCell("two", "dos", 4));
}

项目：guava-mock 文件：ImmutableSetMultimapTest.java

public void testToImmutableSetMultimap() {
  Collector<Entry<String, Integer>, ?, ImmutableSetMultimap<String, Integer>> collector =
      ImmutableSetMultimap.toImmutableSetMultimap(Entry::getKey, Entry::getValue);
  BiPredicate<ImmutableSetMultimap<?, ?>, ImmutableSetMultimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf(
              (ImmutableSetMultimap<?, ?> mm)
                  -> ImmutableListMultimap.copyOf(mm).asMap().entrySet().asList())
          .and(Equivalence.equals());
  CollectorTester.of(collector, equivalence)
      .expectCollects(ImmutableSetMultimap.of())
      .expectCollects(
          ImmutableSetMultimap.of("a", 1, "b", 2, "a", 3, "c", 4),
          mapEntry("a", 1),
          mapEntry("b", 2),
          mapEntry("a", 3),
          mapEntry("c", 4));
}

项目：guava-mock 文件：ImmutableSortedMapTest.java

public void testToImmutableSortedMap() {
  Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
      ImmutableSortedMap.toImmutableSortedMap(
          String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue);
  BiPredicate<ImmutableSortedMap<String, Integer>, ImmutableSortedMap<String, Integer>>
      equivalence =
          Equivalence.equals().onResultOf(ImmutableSortedMap<String, Integer>::comparator)
              .and(Equivalence.equals().onResultOf(map -> map.entrySet().asList()))
              .and(Equivalence.equals());
  ImmutableSortedMap<String, Integer> expected =
      ImmutableSortedMap.<String, Integer>orderedBy(String.CASE_INSENSITIVE_ORDER)
          .put("one", 1)
          .put("three", 3)
          .put("two", 2)
          .build();
  CollectorTester.of(collector, equivalence)
      .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3));
}

项目：guava-mock 文件：ImmutableSortedMapTest.java

public void testToImmutableSortedMapMerging() {
  Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
      ImmutableSortedMap.toImmutableSortedMap(
          Comparator.naturalOrder(), Entry::getKey, Entry::getValue, Integer::sum);
  Equivalence<ImmutableMap<String, Integer>> equivalence =
      Equivalence.equals()
          .<Entry<String, Integer>>pairwise()
          .onResultOf(ImmutableMap::entrySet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          ImmutableSortedMap.of("one", 1, "three", 3, "two", 4),
          mapEntry("one", 1),
          mapEntry("two", 2),
          mapEntry("three", 3),
          mapEntry("two", 2));
}

项目：guava-mock 文件：MapMakerInternalMapTest.java

public void testSetKeyEquivalence() {
  Equivalence<Object> testEquivalence = new Equivalence<Object>() {
    @Override
    protected boolean doEquivalent(Object a, Object b) {
      return false;
    }

    @Override
    protected int doHash(Object t) {
      return 0;
    }
  };

  MapMakerInternalMap<Object, Object, ?, ?> map =
      makeMap(createMapMaker().keyEquivalence(testEquivalence));
  assertSame(testEquivalence, map.keyEquivalence);
  assertSame(map.valueStrength().defaultEquivalence(), map.valueEquivalence());
}

项目：guava-mock 文件：ConcurrentHashMultisetTest.java

private void testLogicalKeyEquality(
    MapMakerInternalMap.Strength keyStrength) {

  ConcurrentMap<String, AtomicInteger> map =
      new MapMaker().setKeyStrength(keyStrength).keyEquivalence(Equivalence.equals()).makeMap();

  ConcurrentHashMultiset<String> multiset = ConcurrentHashMultiset.create(map);

  String s1 = new String("a");
  String s2 = new String("a");
  assertEquals(s1, s2); // Stating the obvious.

  multiset.add(s1);
  assertTrue(multiset.contains(s1));
  assertTrue(multiset.contains(s2));
  assertEquals(1, multiset.count(s1));
  assertEquals(1, multiset.count(s2));

  multiset.add(s2, 3);
  assertEquals(4, multiset.count(s1));
  assertEquals(4, multiset.count(s2));

  multiset.remove(s1);
  assertEquals(3, multiset.count(s1));
  assertEquals(3, multiset.count(s2));
}

项目：googles-monorepo-demo 文件：ImmutableSetMultimapTest.java

public void testFlatteningToImmutableSetMultimap() {
  Collector<String, ?, ImmutableSetMultimap<Character, Character>> collector =
      ImmutableSetMultimap.flatteningToImmutableSetMultimap(
          str -> str.charAt(0), str -> str.substring(1).chars().mapToObj(c -> (char) c));
  BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
          .and(Equivalence.equals());
  ImmutableSetMultimap<Character, Character> empty = ImmutableSetMultimap.of();
  ImmutableSetMultimap<Character, Character> filled =
      ImmutableSetMultimap.<Character, Character>builder()
          .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
          .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
          .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
          .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
          .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
          .build();
  CollectorTester.of(collector, equivalence)
      .expectCollects(empty)
      .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry");
}

项目：guava-mock 文件：MultimapsTest.java

public void testFlatteningToMultimap() {
  Collector<String, ?, ListMultimap<Character, Character>> collector =
      Multimaps.flatteningToMultimap(
          str -> str.charAt(0),
          str -> str.substring(1).chars().mapToObj(c -> (char) c),
          MultimapBuilder.linkedHashKeys().arrayListValues()::build);
  BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
          .and(Equivalence.equals());
  ListMultimap<Character, Character> empty =
      MultimapBuilder.linkedHashKeys().arrayListValues().build();
  ListMultimap<Character, Character> filled =
      MultimapBuilder.linkedHashKeys().arrayListValues().build();
  filled.putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'));
  filled.putAll('a', Arrays.asList('p', 'p', 'l', 'e'));
  filled.putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'));
  filled.putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'));
  filled.putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'));
  CollectorTester.of(collector, equivalence)
      .expectCollects(empty)
      .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry");
}

项目：guava-mock 文件：LocalCacheTest.java

public void testSetKeyEquivalence() {
  Equivalence<Object> testEquivalence = new Equivalence<Object>() {
    @Override
    protected boolean doEquivalent(Object a, Object b) {
      return false;
    }

    @Override
    protected int doHash(Object t) {
      return 0;
    }
  };

  LocalCache<Object, Object> map =
      makeLocalCache(createCacheBuilder().keyEquivalence(testEquivalence));
  assertSame(testEquivalence, map.keyEquivalence);
  assertSame(map.valueStrength.defaultEquivalence(), map.valueEquivalence);
}

项目：guava-mock 文件：LocalCacheTest.java

public void testSetValueEquivalence() {
  Equivalence<Object> testEquivalence = new Equivalence<Object>() {
    @Override
    protected boolean doEquivalent(Object a, Object b) {
      return false;
    }

    @Override
    protected int doHash(Object t) {
      return 0;
    }
  };

  LocalCache<Object, Object> map =
      makeLocalCache(createCacheBuilder().valueEquivalence(testEquivalence));
  assertSame(testEquivalence, map.valueEquivalence);
  assertSame(map.keyStrength.defaultEquivalence(), map.keyEquivalence);
}

项目：googles-monorepo-demo 文件：TablesTest.java

public void testToTableMerging() {
  Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector =
      Tables.toTable(
          Cell::getRowKey,
          Cell::getColumnKey,
          Cell::getValue,
          Integer::sum,
          HashBasedTable::create);
  Equivalence<Table<String, String, Integer>> equivalence =
      Equivalence.equals().<Cell<String, String, Integer>>pairwise().onResultOf(Table::cellSet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          new ImmutableTable.Builder<String, String, Integer>()
              .put("one", "uno", 1)
              .put("two", "dos", 6)
              .put("three", "tres", 3)
              .build(),
          Tables.immutableCell("one", "uno", 1),
          Tables.immutableCell("two", "dos", 2),
          Tables.immutableCell("three", "tres", 3),
          Tables.immutableCell("two", "dos", 4));
}

项目：googles-monorepo-demo 文件：TablesTest.java

public void testToTable() {
  Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector =
      Tables.toTable(Cell::getRowKey, Cell::getColumnKey, Cell::getValue, HashBasedTable::create);
  Equivalence<Table<String, String, Integer>> equivalence =
      Equivalence.equals().<Cell<String, String, Integer>>pairwise().onResultOf(Table::cellSet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          new ImmutableTable.Builder<String, String, Integer>()
              .put("one", "uno", 1)
              .put("two", "dos", 2)
              .put("three", "tres", 3)
              .build(),
          Tables.immutableCell("one", "uno", 1),
          Tables.immutableCell("two", "dos", 2),
          Tables.immutableCell("three", "tres", 3));
}

项目：googles-monorepo-demo 文件：ImmutableSetMultimapTest.java

public void testToImmutableSetMultimap() {
  Collector<Entry<String, Integer>, ?, ImmutableSetMultimap<String, Integer>> collector =
      ImmutableSetMultimap.toImmutableSetMultimap(Entry::getKey, Entry::getValue);
  BiPredicate<ImmutableSetMultimap<?, ?>, ImmutableSetMultimap<?, ?>> equivalence =
      Equivalence.equals()
          .onResultOf(
              (ImmutableSetMultimap<?, ?> mm)
                  -> ImmutableListMultimap.copyOf(mm).asMap().entrySet().asList())
          .and(Equivalence.equals());
  CollectorTester.of(collector, equivalence)
      .expectCollects(ImmutableSetMultimap.of())
      .expectCollects(
          ImmutableSetMultimap.of("a", 1, "b", 2, "a", 3, "c", 4),
          mapEntry("a", 1),
          mapEntry("b", 2),
          mapEntry("a", 3),
          mapEntry("c", 4));
}

项目：googles-monorepo-demo 文件：ImmutableTableTest.java

public void testToImmutableTableMerging() {
  Collector<Cell<String, String, Integer>, ?, ImmutableTable<String, String, Integer>> collector =
      ImmutableTable.toImmutableTable(
          Cell::getRowKey, Cell::getColumnKey, Cell::getValue, Integer::sum);
  Equivalence<ImmutableTable<String, String, Integer>> equivalence =
      Equivalence.equals()
          .<Cell<String, String, Integer>>pairwise()
          .onResultOf(ImmutableTable::cellSet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          new ImmutableTable.Builder<String, String, Integer>()
              .put("one", "uno", 1)
              .put("two", "dos", 6)
              .put("three", "tres", 3)
              .build(),
          Tables.immutableCell("one", "uno", 1),
          Tables.immutableCell("two", "dos", 2),
          Tables.immutableCell("three", "tres", 3),
          Tables.immutableCell("two", "dos", 4));
}

项目：Reer 文件：CandidateMethods.java

/**
 * @return All candidate methods indexed by signature equivalence
 */
public Map<Equivalence.Wrapper<Method>, Collection<Method>> allMethods() {
    ImmutableMap.Builder<Equivalence.Wrapper<Method>, Collection<Method>> builder = ImmutableMap.builder();
    for (Map<Equivalence.Wrapper<Method>, Collection<Method>> candidatesForSomeName : candidates.values()) {
        builder.putAll(candidatesForSomeName);
    }
    return builder.build();
}

项目：googles-monorepo-demo 文件：ForwardingWrapperTesterTest.java

@Override public void foo(
    String s, Runnable r, Number n, Iterable<?> it, boolean b, Equivalence<String> eq,
    Exception e, InputStream in, Comparable<?> c, Ordering<Integer> ord,
    Charset charset, TimeUnit unit, Class<?> cls, Joiner joiner,
    Pattern pattern, UnsignedInteger ui, UnsignedLong ul, StringBuilder sb,
    Predicate<?> pred, Function<?, ?> func, Object obj) {
  delegate.foo(s,
      r, n, it, b, eq, e, in, c, ord, charset, unit, cls, joiner, pattern,
      ui, ul, sb, pred, func, obj);
}

项目：Reer 文件：CandidateMethods.java

/**
 * @param methodName Method name
 * @return Overridden candidate methods named {@literal methodName} indexed by signature equivalence or
 * {@literal null} if none
 */
public Map<Equivalence.Wrapper<Method>, Collection<Method>> overriddenMethodsNamed(String methodName) {
    if (candidates.containsKey(methodName)) {
        return Maps.filterValues(candidates.get(methodName), new Predicate<Collection<Method>>() {
            @Override
            public boolean apply(Collection<Method> equivalentMethods) {
                return equivalentMethods.size() > 1;
            }
        });
    }
    return Collections.<Equivalence.Wrapper<Method>, Collection<Method>>emptyMap();
}

项目：Reer 文件：CandidateMethods.java

/**
 * @param methodName Method name
 * @return Overloaded candidate methods named {@literal methodName} indexed by signature equivalence or
 * {@literal null} if none
 */
Map<Equivalence.Wrapper<Method>, Collection<Method>> overloadedMethodsNamed(String methodName) {
    if (candidates.containsKey(methodName)) {
        Map<Equivalence.Wrapper<Method>, Collection<Method>> overloadeds = candidates.get(methodName);
        if (overloadeds.size() > 1) {
            return overloadeds;
        }
    }
    return Collections.<Equivalence.Wrapper<Method>, Collection<Method>>emptyMap();
}

项目：Reer 文件：SourceFoldersCreator.java

private List<String> getIncludesForTree(SourceSet sourceSet, DirectoryTree directoryTree) {
    List<Set<String>> includesByType = getFiltersForTreeGroupedByType(sourceSet, directoryTree, "includes");
    for (Set<String> it : includesByType) {
        if (it.isEmpty()) {
            return Collections.emptyList();
        }
    }

    List<String> allIncludes = CollectionUtils.flattenCollections(String.class, includesByType);
    return CollectionUtils.dedup(allIncludes, Equivalence.equals());
}

项目：n4js 文件：DependencyTraverser.java

/***/
public DependencyTraverser(final T rootNode, final Equivalence<T> equivalence,
        final Function<T, Collection<? extends T>> dependenciesFunc) {

    this.rootNode = rootNode;
    guard = new RecursionGuard<>(equivalence);
    pathGuard = new RecursionGuard<>(equivalence);
    this.dependenciesFunc = dependenciesFunc;
    cycleNodeEntryRef = new AtomicReference<>(null);
}

项目：guava-mock 文件：MapMakerInternalMap.java

AbstractSerializationProxy(
    Strength keyStrength,
    Strength valueStrength,
    Equivalence<Object> keyEquivalence,
    Equivalence<Object> valueEquivalence,
    int concurrencyLevel,
    ConcurrentMap<K, V> delegate) {
  this.keyStrength = keyStrength;
  this.valueStrength = valueStrength;
  this.keyEquivalence = keyEquivalence;
  this.valueEquivalence = valueEquivalence;
  this.concurrencyLevel = concurrencyLevel;
  this.delegate = delegate;
}

项目：googles-monorepo-demo 文件：ConcurrentHashMultisetTest.java

private void testIdentityKeyEquality(
    MapMakerInternalMap.Strength keyStrength) {

  ConcurrentMap<String, AtomicInteger> map =
      new MapMaker().setKeyStrength(keyStrength).keyEquivalence(Equivalence.identity()).makeMap();

  ConcurrentHashMultiset<String> multiset = ConcurrentHashMultiset.create(map);

  String s1 = new String("a");
  String s2 = new String("a");
  assertEquals(s1, s2); // Stating the obvious.
  assertTrue(s1 != s2); // Stating the obvious.

  multiset.add(s1);
  assertTrue(multiset.contains(s1));
  assertFalse(multiset.contains(s2));
  assertEquals(1, multiset.count(s1));
  assertEquals(0, multiset.count(s2));

  multiset.add(s1);
  multiset.add(s2, 3);
  assertEquals(2, multiset.count(s1));
  assertEquals(3, multiset.count(s2));

  multiset.remove(s1);
  assertEquals(1, multiset.count(s1));
  assertEquals(3, multiset.count(s2));
}

项目：guava-mock 文件：MapMaker.java

/**
 * Sets a custom {@code Equivalence} strategy for comparing keys.
 *
 * <p>By default, the map uses {@link Equivalence#identity} to determine key equality when
 * {@link #weakKeys} is specified, and {@link Equivalence#equals()} otherwise. The only place this
 * is used is in {@link Interners.WeakInterner}.
 */
@CanIgnoreReturnValue
@GwtIncompatible // To be supported
MapMaker keyEquivalence(Equivalence<Object> equivalence) {
  checkState(keyEquivalence == null, "key equivalence was already set to %s", keyEquivalence);
  keyEquivalence = checkNotNull(equivalence);
  this.useCustomMap = true;
  return this;
}

项目：googles-monorepo-demo 文件：ImmutableMapTest.java

public void testToImmutableMap() {
  Collector<Entry<String, Integer>, ?, ImmutableMap<String, Integer>> collector =
      ImmutableMap.toImmutableMap(Entry::getKey, Entry::getValue);
  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));
}

项目：googles-monorepo-demo 文件：ImmutableSetTest.java

public void testToImmutableSet() {
  Collector<String, ?, ImmutableSet<String>> collector = ImmutableSet.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");
}

项目：googles-monorepo-demo 文件：ImmutableEnumMapTest.java

public void testToImmutableEnumMap() {
  Collector<Entry<AnEnum, Integer>, ?, ImmutableMap<AnEnum, Integer>> collector =
      Maps.toImmutableEnumMap(Entry::getKey, Entry::getValue);
  Equivalence<ImmutableMap<AnEnum, Integer>> equivalence =
      Equivalence.equals().<Entry<AnEnum, Integer>>pairwise().onResultOf(ImmutableMap::entrySet);
  CollectorTester.of(collector, equivalence)
      .expectCollects(
          ImmutableMap.of(AnEnum.A, 1, AnEnum.C, 2, AnEnum.E, 3),
          mapEntry(AnEnum.A, 1),
          mapEntry(AnEnum.C, 2),
          mapEntry(AnEnum.E, 3));
}

项目：guava-mock 文件：EqualsTester.java

/**
 * Run tests on equals method, throwing a failure on an invalid test
 */
public EqualsTester testEquals() {
  RelationshipTester<Object> delegate = new RelationshipTester<Object>(
      Equivalence.equals(), "Object#equals", "Object#hashCode", itemReporter);
  for (List<Object> group : equalityGroups) {
    delegate.addRelatedGroup(group);
  }
  for (int run = 0; run < REPETITIONS; run++) {
    testItems();
    delegate.test();
  }
  return this;
}

项目：guava-mock 文件：RelationshipTester.java

RelationshipTester(Equivalence<? super T> equivalence, String relationshipName, String hashName,
    ItemReporter itemReporter) {
  this.equivalence = checkNotNull(equivalence);
  this.relationshipName = checkNotNull(relationshipName);
  this.hashName = checkNotNull(hashName);
  this.itemReporter = checkNotNull(itemReporter);
}

项目：guava-mock 文件：FreshValueGeneratorTest.java

@AndroidIncompatible // problem with equality of Type objects?
public void testFreshInstance() {
  assertFreshInstances(
      String.class, CharSequence.class,
      Appendable.class, StringBuffer.class, StringBuilder.class,
      Pattern.class, MatchResult.class,
      Number.class, int.class, Integer.class,
      long.class, Long.class,
      short.class, Short.class,
      byte.class, Byte.class,
      boolean.class, Boolean.class,
      char.class, Character.class,
      int[].class, Object[].class,
      UnsignedInteger.class, UnsignedLong.class,
      BigInteger.class, BigDecimal.class,
      Throwable.class, Error.class, Exception.class, RuntimeException.class,
      Charset.class, Locale.class, Currency.class,
      List.class, Map.Entry.class,
      Object.class,
      Equivalence.class, Predicate.class, Function.class,
      Comparable.class, Comparator.class, Ordering.class,
      Class.class, Type.class, TypeToken.class,
      TimeUnit.class, Ticker.class,
      Joiner.class, Splitter.class, CharMatcher.class,
      InputStream.class, ByteArrayInputStream.class,
      Reader.class, Readable.class, StringReader.class,
      OutputStream.class, ByteArrayOutputStream.class,
      Writer.class, StringWriter.class, File.class,
      Buffer.class, ByteBuffer.class, CharBuffer.class,
      ShortBuffer.class, IntBuffer.class, LongBuffer.class,
      FloatBuffer.class, DoubleBuffer.class,
      String[].class, Object[].class, int[].class);
}

项目：guava-mock 文件：ForwardingWrapperTesterTest.java

@Override public void foo(
    String s, Runnable r, Number n, Iterable<?> it, boolean b, Equivalence<String> eq,
    Exception e, InputStream in, Comparable<?> c, Ordering<Integer> ord,
    Charset charset, TimeUnit unit, Class<?> cls, Joiner joiner,
    Pattern pattern, UnsignedInteger ui, UnsignedLong ul, StringBuilder sb,
    Predicate<?> pred, Function<?, ?> func, Object obj) {
  delegate.foo(s,
      r, n, it, b, eq, e, in, c, ord, charset, unit, cls, joiner, pattern,
      ui, ul, sb, pred, func, obj);
}