@Generates private static <K, V> ImmutableSetMultimap<K, V> generateImmutableSetMultimap(K key, V value) { return ImmutableSetMultimap.of(key, value); }
private static <K, V> ImmutableSetMultimap<K, V> copyOf( Multimap<? extends K, ? extends V> multimap, Comparator<? super V> valueComparator) { checkNotNull(multimap); // eager for GWT if (multimap.isEmpty() && valueComparator == null) { return of(); } if (multimap instanceof ImmutableSetMultimap) { @SuppressWarnings("unchecked") // safe since multimap is not writable ImmutableSetMultimap<K, V> kvMultimap = (ImmutableSetMultimap<K, V>) multimap; if (!kvMultimap.isPartialView()) { return kvMultimap; } } return fromMapEntries(multimap.asMap().entrySet(), valueComparator); }
public void testInverse() { assertEquals( ImmutableSetMultimap.<Integer, String>of(), ImmutableSetMultimap.<String, Integer>of().inverse()); assertEquals(ImmutableSetMultimap.of(1, "one"), ImmutableSetMultimap.of("one", 1).inverse()); assertEquals( ImmutableSetMultimap.of(1, "one", 2, "two"), ImmutableSetMultimap.of("one", 1, "two", 2).inverse()); assertEquals( ImmutableSetMultimap.of('o', "of", 'f', "of", 't', "to", 'o', "to"), ImmutableSetMultimap.of("of", 'o', "of", 'f', "to", 't', "to", 'o').inverse()); }
@Override protected Map<String, Collection<Integer>> makeEmptyMap() { return ImmutableSetMultimap.<String, Integer>of().asMap(); }
public void testEmptyMultimapWrites() { Multimap<String, Integer> multimap = ImmutableSetMultimap.of(); UnmodifiableCollectionTests.assertMultimapIsUnmodifiable(multimap, "foo", 1); }
public void testAsMultimapWhenEmpty() { ImmutableMap<String, Integer> map = ImmutableMap.of(); ImmutableSetMultimap<String, Integer> expected = ImmutableSetMultimap.of(); assertEquals(expected, map.asMultimap()); }
public void testAsMultimap() { ImmutableMap<String, Integer> map = ImmutableMap.of("one", 1, "won", 1, "two", 2, "too", 2, "three", 3); ImmutableSetMultimap<String, Integer> expected = ImmutableSetMultimap.of("one", 1, "won", 1, "two", 2, "too", 2, "three", 3); assertEquals(expected, map.asMultimap()); }
@Override SetMultimap<String, Integer> filter(SetMultimap<String, Integer> multimap) { ImmutableSetMultimap<String, Integer> badEntries = ImmutableSetMultimap.of("foo", 314, "one", 159, "two", 265, "bar", 358); multimap.putAll(badEntries); multimap = Multimaps.filterEntries( multimap, Predicates.not( Predicates.in(ImmutableMap.of("one", 159, "two", 265).entrySet()))); return Multimaps.filterKeys( multimap, Predicates.not(Predicates.in(ImmutableSet.of("foo", "bar")))); } })
@Override SetMultimap<String, Integer> filter(SetMultimap<String, Integer> multimap) { ImmutableSetMultimap<String, Integer> badEntries = ImmutableSetMultimap.of("foo", 314, "bar", 358); multimap.putAll(badEntries); multimap = Multimaps.filterKeys(multimap, Predicates.not(Predicates.equalTo("foo"))); multimap = Multimaps.filterKeys(multimap, Predicates.not(Predicates.equalTo("bar"))); return multimap; } })
@Override SetMultimap<String, Integer> filter(SetMultimap<String, Integer> multimap) { ImmutableSetMultimap<String, Integer> badEntries = ImmutableSetMultimap.of("foo", 314, "one", 159, "two", 265, "bar", 358); multimap.putAll(badEntries); multimap = Multimaps.filterKeys( multimap, Predicates.not(Predicates.in(ImmutableSet.of("foo", "bar")))); return Multimaps.filterEntries( multimap, Predicates.not(Predicates.in(badEntries.entries()))); } })
@Override SetMultimap<String, Integer> filter(SetMultimap<String, Integer> multimap) { ImmutableSetMultimap<String, Integer> badEntries = ImmutableSetMultimap.of("foo", 314, "one", 159, "two", 265, "bar", 358); multimap.putAll(badEntries); return Multimaps.filterEntries( multimap, Predicates.not(Predicates.in(badEntries.entries()))); } })
@GwtIncompatible(value = "untested") public void testTransformEntries() { SetMultimap<String, Integer> multimap = ImmutableSetMultimap.of("a", 1, "a", 4, "b", -6); EntryTransformer<String, Integer, String> transformer = new EntryTransformer<String, Integer, String>() { @Override public String transformEntry(String key, Integer value) { return (value >= 0) ? key : "no" + key; } }; Multimap<String, String> transformed = Multimaps.transformEntries(multimap, transformer); assertThat(transformed.entries()) .containsExactly( immutableEntry("a", "a"), immutableEntry("a", "a"), immutableEntry("b", "nob")) .inOrder(); }
/** * Returns a multimap view of the map. * * @since 14.0 */ public ImmutableSetMultimap<K, V> asMultimap() { if (isEmpty()) { return ImmutableSetMultimap.of(); } ImmutableSetMultimap<K, V> result = multimapView; return (result == null) ? (multimapView = new ImmutableSetMultimap<>(new MapViewOfValuesAsSingletonSets(), size(), null)) : result; }
@GwtIncompatible // SerializableTester public void testEmptySerialization() { Multimap<String, Integer> multimap = ImmutableSetMultimap.of(); assertSame(multimap, SerializableTester.reserialize(multimap)); }
public void testEmptyMultimapReads() { Multimap<String, Integer> multimap = ImmutableSetMultimap.of(); assertFalse(multimap.containsKey("foo")); assertFalse(multimap.containsValue(1)); assertFalse(multimap.containsEntry("foo", 1)); assertTrue(multimap.entries().isEmpty()); assertTrue(multimap.equals(HashMultimap.create())); assertEquals(Collections.emptySet(), multimap.get("foo")); assertEquals(0, multimap.hashCode()); assertTrue(multimap.isEmpty()); assertEquals(HashMultiset.create(), multimap.keys()); assertEquals(Collections.emptySet(), multimap.keySet()); assertEquals(0, multimap.size()); assertTrue(multimap.values().isEmpty()); assertEquals("{}", multimap.toString()); }
public void testCopyOf() { ImmutableSetMultimap<String, String> setMultimap = ImmutableSetMultimap.of("k1", "v1"); ImmutableMultimap<String, String> setMultimapCopy = ImmutableMultimap.copyOf(setMultimap); assertSame( "copyOf(ImmutableSetMultimap) should not create a new instance", setMultimap, setMultimapCopy); ImmutableListMultimap<String, String> listMultimap = ImmutableListMultimap.of("k1", "v1"); ImmutableMultimap<String, String> listMultimapCopy = ImmutableMultimap.copyOf(listMultimap); assertSame( "copyOf(ImmutableListMultimap) should not create a new instance", listMultimap, listMultimapCopy); }
@SuppressWarnings("deprecation") public void testUnmodifiableSetMultimapShortCircuit() { SetMultimap<String, Integer> mod = HashMultimap.create(); SetMultimap<String, Integer> unmod = Multimaps.unmodifiableSetMultimap(mod); assertNotSame(mod, unmod); assertSame(unmod, Multimaps.unmodifiableSetMultimap(unmod)); ImmutableSetMultimap<String, Integer> immutable = ImmutableSetMultimap.of("a", 1, "b", 2, "a", 3); assertSame(immutable, Multimaps.unmodifiableSetMultimap(immutable)); assertSame( immutable, Multimaps.unmodifiableSetMultimap((SetMultimap<String, Integer>) immutable)); }
public void testInverseMinimizesWork() { ImmutableSetMultimap<String, Character> multimap = ImmutableSetMultimap.of("of", 'o', "of", 'f', "to", 't', "to", 'o'); assertSame(multimap.inverse(), multimap.inverse()); assertSame(multimap, multimap.inverse().inverse()); }
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)); }