public void testDifferenceWithRemovedElement() { Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); Multiset<String> ms2 = HashMultiset.create(Arrays.asList("b")); assertThat(Multisets.difference(ms1, ms2)).containsExactly("a", "a"); }
public void testDifferenceEmptyNonempty() { Multiset<String> ms1 = HashMultiset.create(); Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); assertEquals(ms1, Multisets.difference(ms1, ms2)); }
public void testDifferenceWithNoRemovedElements() { Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a")); assertThat(Multisets.difference(ms1, ms2)).containsExactly("a", "b"); }
public void testDifferenceNonemptyEmpty() { Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); Multiset<String> ms2 = HashMultiset.create(); assertEquals(ms1, Multisets.difference(ms1, ms2)); }
@Override protected Multiset<String> create(String[] elements) { Multiset<String> multiset1 = LinkedHashMultiset.create(); Multiset<String> multiset2 = LinkedHashMultiset.create(); multiset1.add("equalIn1"); multiset1.add("fewerIn1"); multiset2.add("equalIn1"); multiset2.add("fewerIn1", 3); multiset2.add("onlyIn2", 2); for (int i = 0; i < elements.length; i++) { // add 1 more copy of each element to multiset1 than multiset2 multiset1.add(elements[i], i + 2); multiset2.add(elements[i], i + 1); } return Multisets.difference(multiset1, multiset2); } };
public static void assertEqualsIgnoreOrder(Iterable<?> actual, Iterable<?> expected, String message) { assertNotNull(actual, "actual is null"); assertNotNull(expected, "expected is null"); ImmutableMultiset<?> actualSet = ImmutableMultiset.copyOf(actual); ImmutableMultiset<?> expectedSet = ImmutableMultiset.copyOf(expected); if (!actualSet.equals(expectedSet)) { Multiset<?> unexpectedRows = Multisets.difference(actualSet, expectedSet); Multiset<?> missingRows = Multisets.difference(expectedSet, actualSet); int limit = 100; fail(format( "%snot equal\n" + "Actual rows (up to %s of %s extra rows shown, %s rows in total):\n %s\n" + "Expected rows (up to %s of %s missing rows shown, %s rows in total):\n %s\n", message == null ? "" : (message + "\n"), limit, unexpectedRows.size(), actualSet.size(), Joiner.on("\n ").join(Iterables.limit(unexpectedRows, limit)), limit, missingRows.size(), expectedSet.size(), Joiner.on("\n ").join(Iterables.limit(missingRows, limit)))); } }
public String getResultsComparison(int precision) { List<List<Object>> controlResults = controlResult.getResults(); List<List<Object>> testResults = testResult.getResults(); if (valid() || (controlResults == null) || (testResults == null)) { return ""; } Multiset<List<Object>> control = ImmutableSortedMultiset.copyOf(rowComparator(precision), controlResults); Multiset<List<Object>> test = ImmutableSortedMultiset.copyOf(rowComparator(precision), testResults); try { Iterable<ChangedRow> diff = ImmutableSortedMultiset.<ChangedRow>naturalOrder() .addAll(Iterables.transform(Multisets.difference(control, test), row -> new ChangedRow(Changed.REMOVED, row, precision))) .addAll(Iterables.transform(Multisets.difference(test, control), row -> new ChangedRow(Changed.ADDED, row, precision))) .build(); diff = Iterables.limit(diff, 100); StringBuilder sb = new StringBuilder(); sb.append(format("Control %s rows, Test %s rows%n", control.size(), test.size())); if (verboseResultsComparison) { Joiner.on("\n").appendTo(sb, diff); } else { sb.append("RESULTS DO NOT MATCH\n"); } return sb.toString(); } catch (TypesDoNotMatchException e) { return e.getMessage(); } }
public void testDifferenceWithMoreElementsInSecondMultiset() { Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "b", "b")); Multiset<String> diff = Multisets.difference(ms1, ms2); assertThat(diff).contains("a"); assertEquals(0, diff.count("b")); assertEquals(1, diff.count("a")); assertFalse(diff.contains("b")); assertTrue(diff.contains("a")); }
private List<ContainerElementChange> calculateEntryChanges(MultisetType multisetType, Multiset left, Multiset right, OwnerContext owner){ JaversType itemType = typeMapper.getJaversType(multisetType.getItemType()); DehydrateContainerFunction dehydrateFunction = new DehydrateContainerFunction(itemType, globalIdFactory); Multiset leftMultiset = (Multiset) multisetType.map(left,dehydrateFunction,owner); Multiset rightMultiset = (Multiset) multisetType.map(right,dehydrateFunction,owner); List<ContainerElementChange> changes = new ArrayList<>(); for (Object globalCdoId : Multisets.difference(leftMultiset, rightMultiset)){ changes.add(new ValueRemoved(globalCdoId)); } Multiset difference = Multisets.difference(rightMultiset, leftMultiset); for (Object globalCdoId : difference){ changes.add(new ValueAdded(globalCdoId)); } return changes; } }
public void testDifferenceWithNoRemovedElements() { Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a")); assertThat(Multisets.difference(ms1, ms2)).containsExactly("a", "b"); }
public void testDifferenceWithRemovedElement() { Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); Multiset<String> ms2 = HashMultiset.create(Arrays.asList("b")); assertThat(Multisets.difference(ms1, ms2)).containsExactly("a", "a"); }
public void testDifferenceEmptyNonempty() { Multiset<String> ms1 = HashMultiset.create(); Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "a")); assertEquals(ms1, Multisets.difference(ms1, ms2)); }
public void testDifferenceNonemptyEmpty() { Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); Multiset<String> ms2 = HashMultiset.create(); assertEquals(ms1, Multisets.difference(ms1, ms2)); }
public static void assertEqualsIgnoreOrder(Iterable<?> actual, Iterable<?> expected, String message) { assertNotNull(actual, "actual is null"); assertNotNull(expected, "expected is null"); ImmutableMultiset<?> actualSet = ImmutableMultiset.copyOf(actual); ImmutableMultiset<?> expectedSet = ImmutableMultiset.copyOf(expected); if (!actualSet.equals(expectedSet)) { Multiset<?> unexpectedRows = Multisets.difference(actualSet, expectedSet); Multiset<?> missingRows = Multisets.difference(expectedSet, actualSet); int limit = 100; fail(format( "%snot equal\n" + "Actual rows (up to %s of %s extra rows shown, %s rows in total):\n %s\n" + "Expected rows (up to %s of %s missing rows shown, %s rows in total):\n %s\n", message == null ? "" : (message + "\n"), limit, unexpectedRows.size(), actualSet.size(), Joiner.on("\n ").join(Iterables.limit(unexpectedRows, limit)), limit, missingRows.size(), expectedSet.size(), Joiner.on("\n ").join(Iterables.limit(missingRows, limit)))); } }
public static void assertEqualsIgnoreOrder(Iterable<?> actual, Iterable<?> expected, String message) { assertNotNull(actual, "actual is null"); assertNotNull(expected, "expected is null"); ImmutableMultiset<?> actualSet = ImmutableMultiset.copyOf(actual); ImmutableMultiset<?> expectedSet = ImmutableMultiset.copyOf(expected); if (!actualSet.equals(expectedSet)) { Multiset<?> unexpectedRows = Multisets.difference(actualSet, expectedSet); Multiset<?> missingRows = Multisets.difference(expectedSet, actualSet); int limit = 100; fail(format( "%snot equal\n" + "Actual rows (up to %s of %s extra rows shown, %s rows in total):\n %s\n" + "Expected rows (up to %s of %s missing rows shown, %s rows in total):\n %s\n", message == null ? "" : (message + "\n"), limit, unexpectedRows.size(), actualSet.size(), Joiner.on("\n ").join(Iterables.limit(unexpectedRows, limit)), limit, missingRows.size(), expectedSet.size(), Joiner.on("\n ").join(Iterables.limit(missingRows, limit)))); } }
@Override protected Multiset<String> create(String[] elements) { Multiset<String> multiset1 = LinkedHashMultiset.create(); Multiset<String> multiset2 = LinkedHashMultiset.create(); multiset1.add("equalIn1"); multiset1.add("fewerIn1"); multiset2.add("equalIn1"); multiset2.add("fewerIn1", 3); multiset2.add("onlyIn2", 2); for (int i = 0; i < elements.length; i++) { // add 1 more copy of each element to multiset1 than multiset2 multiset1.add(elements[i], i + 2); multiset2.add(elements[i], i + 1); } return Multisets.difference(multiset1, multiset2); } };
allocationSize - baseline.allocationSize, reps - baseline.reps, Multisets.difference(allocations, baseline.allocations)); } catch (IllegalArgumentException e) { throw new IllegalStateException(String.format(
public String getResultsComparison(int precision) { List<List<Object>> controlResults = controlResult.getResults(); List<List<Object>> testResults = testResult.getResults(); if (valid() || (controlResults == null) || (testResults == null)) { return ""; } Multiset<List<Object>> control = ImmutableSortedMultiset.copyOf(rowComparator(precision), controlResults); Multiset<List<Object>> test = ImmutableSortedMultiset.copyOf(rowComparator(precision), testResults); try { Iterable<ChangedRow> diff = ImmutableSortedMultiset.<ChangedRow>naturalOrder() .addAll(Iterables.transform(Multisets.difference(control, test), row -> new ChangedRow(Changed.REMOVED, row, precision))) .addAll(Iterables.transform(Multisets.difference(test, control), row -> new ChangedRow(Changed.ADDED, row, precision))) .build(); diff = Iterables.limit(diff, 100); StringBuilder sb = new StringBuilder(); sb.append(format("Control %s rows, Test %s rows%n", control.size(), test.size())); if (verboseResultsComparison) { Joiner.on("\n").appendTo(sb, diff); } else { sb.append("RESULTS DO NOT MATCH\n"); } return sb.toString(); } catch (TypesDoNotMatchException e) { return e.getMessage(); } }
public void testDifferenceWithMoreElementsInSecondMultiset() { Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a")); Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a", "b", "b", "b")); Multiset<String> diff = Multisets.difference(ms1, ms2); assertThat(diff).contains("a"); assertEquals(0, diff.count("b")); assertEquals(1, diff.count("a")); assertFalse(diff.contains("b")); assertTrue(diff.contains("a")); }
public static Term difference(BuiltinMap map1, BuiltinMap map2, TermContext context) { BuiltinMap.Builder builder = BuiltinMap.builder(context.global()); if (!map1.isGround() || !map2.isGround()) { if (map1.getEntries().entrySet().containsAll(map2.getEntries().entrySet()) && Multisets.containsOccurrences(map1.baseTerms(), map2.baseTerms())) { builder.putAll(Maps.difference(map1.getEntries(), map2.getEntries()).entriesOnlyOnLeft()); builder.concatenate(Multisets.difference(map1.baseTerms(), map2.baseTerms())); return builder.build(); } else { return null; } } else { /* Maps.difference breaks down the Venn diagram into four parts, see: * http://code.google.com/p/guava-libraries/wiki/CollectionUtilitiesExplained#difference */ MapDifference<Term, Term> mapDiff = Maps.difference(map1.getEntries(), map2.getEntries()); builder.putAll(mapDiff.entriesOnlyOnLeft()); for (Entry<Term, ValueDifference<Term>> e : mapDiff.entriesDiffering().entrySet()) { builder.put(e.getKey(), e.getValue().leftValue()); } return builder.build(); } }