项目：guava-mock
文件：MapsTest.java
public void testMapDifferenceTypical() {
Map<Integer,String> left = ImmutableMap.of(
1,"a",2,"b",3,"c",4,"d",5,"e");
Map<Integer,String> right = ImmutableMap.of(
1,"f","g",6,"z");
MapDifference<Integer,String> diff1 = Maps.difference(left,right);
assertFalse(diff1.areEqual());
assertEquals(ImmutableMap.of(2,"d"),diff1.entriesOnlyOnLeft());
assertEquals(ImmutableMap.of(6,"z"),diff1.entriesOnlyOnRight());
assertEquals(ImmutableMap.of(1,"a"),diff1.entriesInCommon());
assertEquals(ImmutableMap.of(3,ValueDifferenceImpl.create("c","f"),ValueDifferenceImpl.create("e","g")),diff1.entriesDiffering());
assertEquals("not equal: only on left={2=b,4=d}: only on right={6=z}: "
+ "value differences={3=(c,f),5=(e,g)}",diff1.toString());
MapDifference<Integer,String> diff2 = Maps.difference(right,left);
assertFalse(diff2.areEqual());
assertEquals(ImmutableMap.of(6,diff2.entriesOnlyOnLeft());
assertEquals(ImmutableMap.of(2,diff2.entriesOnlyOnRight());
assertEquals(ImmutableMap.of(1,diff2.entriesInCommon());
assertEquals(ImmutableMap.of(3,ValueDifferenceImpl.create("f","c"),ValueDifferenceImpl.create("g","e")),diff2.entriesDiffering());
assertEquals("not equal: only on left={6=z}: only on right={2=b,4=d}: "
+ "value differences={3=(f,c),5=(g,e)}",diff2.toString());
}
项目：guava-mock
文件：MapsTest.java
public void testSortedMapDifferenceTypical() {
SortedMap<Integer,String> left =
ImmutableSortedMap.<Integer,String>reverseOrder()
.put(1,"a").put(2,"b").put(3,"c").put(4,"d").put(5,"e")
.build();
SortedMap<Integer,String> right =
ImmutableSortedMap.of(1,"z");
SortedMapDifference<Integer,String> diff1 =
Maps.difference(left,right);
assertFalse(diff1.areEqual());
assertThat(diff1.entriesOnlyOnLeft().entrySet()).containsExactly(
Maps.immutableEntry(4,Maps.immutableEntry(2,"b")).inOrder();
assertThat(diff1.entriesOnlyOnRight().entrySet()).contains(
Maps.immutableEntry(6,"z"));
assertThat(diff1.entriesInCommon().entrySet()).contains(
Maps.immutableEntry(1,"a"));
assertThat(diff1.entriesDiffering().entrySet()).containsExactly(
Maps.immutableEntry(5,Maps.immutableEntry(3,"f"))).inOrder();
assertEquals("not equal: only on left={4=d,2=b}: only on right={6=z}: "
+ "value differences={5=(e,g),3=(c,f)}",diff1.toString());
SortedMapDifference<Integer,String> diff2 =
Maps.difference(right,left);
assertFalse(diff2.areEqual());
assertThat(diff2.entriesOnlyOnLeft().entrySet()).contains(
Maps.immutableEntry(6,"z"));
assertThat(diff2.entriesOnlyOnRight().entrySet()).containsExactly(
Maps.immutableEntry(2,"b"),Maps.immutableEntry(4,"d")).inOrder();
assertThat(diff1.entriesInCommon().entrySet()).contains(
Maps.immutableEntry(1,"a"));
assertEquals(ImmutableMap.of(
3,diff2.toString());
}
项目：googles-monorepo-demo
文件：MapsTest.java
public void testMapDifferenceTypical() {
Map<Integer,diff2.toString());
}
项目：googles-monorepo-demo
文件：MapsTest.java
public void testSortedMapDifferenceTypical() {
SortedMap<Integer,diff2.toString());
}
项目：VarJ
文件：SortedMaps.java
/**
* Computes the difference between two sorted maps,using the comparator of
* the left map,or {@code Ordering.natural()} if the left map uses the
* natural ordering of its elements. This difference is an immutable snapshot
* of the state of the maps at the time this method is called. It will never
* change,even if the maps change at a later time.
*
* <p>Since this method uses {@code TreeMap} instances internally,the keys of
* the right map must all compare as distinct according to the comparator
* of the left map.
*
* <p><b>Note:</b>If you only need to know whether two sorted maps have the
* same mappings,call {@code left.equals(right)} instead of this method.
*
* @param left the map to treat as the "left" map for purposes of comparison
* @param right the map to treat as the "right" map for purposes of comparison
* @return the difference between the two maps
*/
public static <K,V> SortedMapDifference<K,V> difference(
SortedMap<K,? extends V> left,Map<? extends K,? extends V> right) {
Comparator<? super K> comparator = orNaturalOrder(left.comparator());
SortedMap<K,V> onlyOnLeft = Maps.newTreeMap(comparator);
SortedMap<K,V> onlyOnRight = Maps.newTreeMap(comparator);
onlyOnRight.putAll(right); // will whittle it down
SortedMap<K,V> onBoth = Maps.newTreeMap(comparator);
SortedMap<K,MapDifference.ValueDifference<V>> differences =
Maps.newTreeMap(comparator);
boolean eq = true;
for (Entry<? extends K,? extends V> entry : left.entrySet()) {
K leftKey = entry.getKey();
V leftValue = entry.getValue();
if (right.containsKey(leftKey)) {
V rightValue = onlyOnRight.remove(leftKey);
if (Objects.equal(leftValue,rightValue)) {
onBoth.put(leftKey,leftValue);
} else {
eq = false;
differences.put(
leftKey,new ValueDifferenceImpl<V>(leftValue,rightValue));
}
} else {
eq = false;
onlyOnLeft.put(leftKey,leftValue);
}
}
boolean areEqual = eq && onlyOnRight.isEmpty();
return sortedMapDifference(
areEqual,onlyOnLeft,onlyOnRight,onBoth,differences);
}
项目：guava-libraries
文件：MapsTest.java
public void testMapDifferenceTypical() {
Map<Integer,diff2.toString());
}
项目：guava-libraries
文件：MapsTest.java
public void testSortedMapDifferenceTypical() {
SortedMap<Integer,diff2.toString());
}
项目：guava
文件：MapsTest.java
public void testMapDifferenceTypical() {
Map<Integer,String> left = ImmutableMap.of(1,String> right = ImmutableMap.of(1,diff1.entriesInCommon());
assertEquals(
ImmutableMap.of(
3,diff1.entriesDiffering());
assertEquals(
"not equal: only on left={2=b,4=d}: only on right={6=z}: "
+ "value differences={3=(c,diff2.entriesInCommon());
assertEquals(
ImmutableMap.of(
3,diff2.entriesDiffering());
assertEquals(
"not equal: only on left={6=z}: only on right={2=b,4=d}: "
+ "value differences={3=(f,diff2.toString());
}
项目：guava-mock
文件：MapsTest.java
public void testMapDifferencePredicateTypical() {
Map<Integer,"A","F","G","Z");
// TODO(kevinb): replace with Ascii.caseInsensitiveEquivalence() when it
// exists
Equivalence<String> caseInsensitiveEquivalence = Equivalence.equals().onResultOf(
new Function<String,String>() {
@Override public String apply(String input) {
return input.toLowerCase();
}
});
MapDifference<Integer,right,caseInsensitiveEquivalence);
assertFalse(diff1.areEqual());
assertEquals(ImmutableMap.of(2,"Z"),"F"),"G")),4=d}: only on right={6=Z}: "
+ "value differences={3=(c,F),G)}",left,caseInsensitiveEquivalence);
assertFalse(diff2.areEqual());
assertEquals(ImmutableMap.of(6,"A"),ValueDifferenceImpl.create("F",ValueDifferenceImpl.create("G",diff2.entriesDiffering());
assertEquals("not equal: only on left={6=Z}: only on right={2=b,4=d}: "
+ "value differences={3=(F,5=(G,diff2.toString());
}
项目：googles-monorepo-demo
文件：MapsTest.java
public void testMapDifferencePredicateTypical() {
Map<Integer,diff2.toString());
}
项目：guava-libraries
文件：MapsTest.java
public void testMapDifferencePredicateTypical() {
Map<Integer,diff2.toString());
}
项目：guava
文件：MapsTest.java
public void testMapDifferencePredicateTypical() {
Map<Integer,"Z");
// TODO(kevinb): replace with Ascii.caseInsensitiveEquivalence() when it
// exists
Equivalence<String> caseInsensitiveEquivalence =
Equivalence.equals()
.onResultOf(
new Function<String,String>() {
@Override
public String apply(String input) {
return input.toLowerCase();
}
});
MapDifference<Integer,4=d}: only on right={6=Z}: "
+ "value differences={3=(c,diff2.entriesDiffering());
assertEquals(
"not equal: only on left={6=Z}: only on right={2=b,4=d}: "
+ "value differences={3=(F,diff2.toString());
}
项目：guava
文件：MapsTest.java
public void testSortedMapDifferenceTypical() {
SortedMap<Integer,String>reverseOrder()
.put(1,"a")
.put(2,"b")
.put(3,"c")
.put(4,"d")
.put(5,"e")
.build();
SortedMap<Integer,String> right = ImmutableSortedMap.of(1,right);
assertFalse(diff1.areEqual());
assertThat(diff1.entriesOnlyOnLeft().entrySet())
.containsExactly(Maps.immutableEntry(4,"b"))
.inOrder();
assertThat(diff1.entriesOnlyOnRight().entrySet()).contains(Maps.immutableEntry(6,"z"));
assertThat(diff1.entriesInCommon().entrySet()).contains(Maps.immutableEntry(1,"a"));
assertThat(diff1.entriesDiffering().entrySet())
.containsExactly(
Maps.immutableEntry(5,"f")))
.inOrder();
assertEquals(
"not equal: only on left={4=d,2=b}: only on right={6=z}: "
+ "value differences={5=(e,left);
assertFalse(diff2.areEqual());
assertThat(diff2.entriesOnlyOnLeft().entrySet()).contains(Maps.immutableEntry(6,"z"));
assertThat(diff2.entriesOnlyOnRight().entrySet())
.containsExactly(Maps.immutableEntry(2,"d"))
.inOrder();
assertThat(diff1.entriesInCommon().entrySet()).contains(Maps.immutableEntry(1,"a"));
assertEquals(
ImmutableMap.of(
3,diff2.toString());
}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。