@Override Equivalence<Object> defaultEquivalence() { return Equivalence.equals(); } },
@Override Equivalence<Object> defaultEquivalence() { return Equivalence.equals(); } },
private InternerImpl(MapMaker mapMaker) { this.map = MapMakerInternalMap.createWithDummyValues(mapMaker.keyEquivalence(Equivalence.equals())); }
/** Run tests on equals method, throwing a failure on an invalid test */ public EqualsTester testEquals() { RelationshipTester<Object> delegate = new RelationshipTester<>( 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; }
@Override public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) { // We use a "custom" equivalence to force MapMaker to make a MapMakerInternalMap. ConcurrentMap<K, V> newMap = new MapMaker().keyEquivalence(Equivalence.equals()).makeMap(); checkState(newMap instanceof MapMakerInternalMap); newMap.putAll(map); return newMap; } },
public void testToImmutableSortedSet() { Collector<String, ?, ImmutableSortedSet<String>> collector = ImmutableSortedSet.toImmutableSortedSet(Ordering.natural()); BiPredicate<ImmutableSortedSet<String>, ImmutableSortedSet<String>> equivalence = Equivalence.equals() .onResultOf(ImmutableSortedSet<String>::comparator) .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"); }
@SuppressWarnings("unchecked") // varargs public void testPairwiseEquivalent() { EquivalenceTester.of(Equivalence.equals().<String>pairwise()) .addEquivalenceGroup(ImmutableList.<String>of()) .addEquivalenceGroup(ImmutableList.of("a")) .addEquivalenceGroup(ImmutableList.of("b")) .addEquivalenceGroup(ImmutableList.of("a", "b"), ImmutableList.of("a", "b")) .test(); }
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"); }
public void testEqualsEquivalent() { EquivalenceTester.of(Equivalence.equals()) .addEquivalenceGroup(new Integer(42), 42) .addEquivalenceGroup("a") .test(); }
public void testEquivalentTo() { Predicate<Object> equalTo1 = Equivalence.equals().equivalentTo("1"); assertTrue(equalTo1.apply("1")); assertFalse(equalTo1.apply("2")); assertFalse(equalTo1.apply(null)); Predicate<Object> isNull = Equivalence.equals().equivalentTo(null); assertFalse(isNull.apply("1")); assertFalse(isNull.apply("2")); assertTrue(isNull.apply(null)); new EqualsTester() .addEqualityGroup(equalTo1, Equivalence.equals().equivalentTo("1")) .addEqualityGroup(isNull) .addEqualityGroup(Equivalence.identity().equivalentTo("1")) .testEquals(); }
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)); }
@GwtIncompatible // SerializableTester public void testSerialization() { SerializableTester.reserializeAndAssert(LENGTH_EQUIVALENCE.wrap("hello")); SerializableTester.reserializeAndAssert(Equivalence.equals()); SerializableTester.reserializeAndAssert(Equivalence.identity()); }
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)); }
public void testWrap() { new EqualsTester() .addEqualityGroup( LENGTH_EQUIVALENCE.wrap("hello"), LENGTH_EQUIVALENCE.wrap("hello"), LENGTH_EQUIVALENCE.wrap("world")) .addEqualityGroup(LENGTH_EQUIVALENCE.wrap("hi"), LENGTH_EQUIVALENCE.wrap("yo")) .addEqualityGroup(LENGTH_EQUIVALENCE.wrap(null), LENGTH_EQUIVALENCE.wrap(null)) .addEqualityGroup(Equivalence.equals().wrap("hello")) .addEqualityGroup(Equivalence.equals().wrap(null)) .testEquals(); }
@GwtIncompatible // NullPointerTester public void testNulls() { new NullPointerTester().testAllPublicStaticMethods(Equivalence.class); new NullPointerTester().testAllPublicInstanceMethods(Equivalence.equals()); new NullPointerTester().testAllPublicInstanceMethods(Equivalence.identity()); } }
public void testOnResultOf() { EquivalenceTester.of(Equivalence.equals().onResultOf(Functions.toStringFunction())) .addEquivalenceGroup(new IntValue(1), new IntValue(1)) .addEquivalenceGroup(new IntValue(2)) .test(); }
public void testToImmutableBiMap() { Collector<Entry<String, Integer>, ?, ImmutableBiMap<String, Integer>> collector = ImmutableBiMap.toImmutableBiMap(Entry::getKey, Entry::getValue); Equivalence<ImmutableBiMap<String, Integer>> equivalence = 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)); }
public void testOnResultOf_equals() { new EqualsTester() .addEqualityGroup( Equivalence.identity().onResultOf(Functions.toStringFunction()), Equivalence.identity().onResultOf(Functions.toStringFunction())) .addEqualityGroup(Equivalence.equals().onResultOf(Functions.toStringFunction())) .addEqualityGroup(Equivalence.identity().onResultOf(Functions.identity())) .testEquals(); }