/** * Returns {@link ListMultimap#asMap multimap.asMap()}, with its type corrected from {@code Map<K, * Collection<V>>} to {@code Map<K, List<V>>}. * * @since 15.0 */ @Beta @SuppressWarnings("unchecked") // safe by specification of ListMultimap.asMap() public static <K, V> Map<K, List<V>> asMap(ListMultimap<K, V> multimap) { return (Map<K, List<V>>) (Map<K, ?>) multimap.asMap(); }
@SuppressWarnings({"unchecked", "rawtypes"}) private FreshValueGenerator newFreshValueGenerator() { FreshValueGenerator generator = new FreshValueGenerator() { @Override Object interfaceMethodCalled(Class<?> interfaceType, Method method) { return getDummyValue(TypeToken.of(interfaceType).method(method).getReturnType()); } }; for (Entry<Class<?>, Collection<Object>> entry : distinctValues.asMap().entrySet()) { generator.addSampleInstances((Class) entry.getKey(), entry.getValue()); } return generator; }
/** * Returns the output to input symbol mapping for the given source channel */ public Map<Symbol, SymbolReference> sourceSymbolMap(int sourceIndex) { ImmutableMap.Builder<Symbol, SymbolReference> builder = ImmutableMap.builder(); for (Map.Entry<Symbol, Collection<Symbol>> entry : outputToInputs.asMap().entrySet()) { builder.put(entry.getKey(), Iterables.get(entry.getValue(), sourceIndex).toSymbolReference()); } return builder.build(); }
public void testAsMapValuesImplementList() { for (Collection<V> valueCollection : multimap().asMap().values()) { assertTrue(valueCollection instanceof List); } }
private static Response responseWithHeaders(ResponseBuilder builder, ProxyResponse response) { response.getHeaders().asMap().forEach((headerName, value) -> { String name = headerName.toString(); if (isPrestoHeader(name) || name.equalsIgnoreCase(SET_COOKIE)) { builder.header(name, value); } }); return builder.build(); }
public void testAsMapGetImplementsList() { for (K key : multimap().keySet()) { assertTrue(multimap().asMap().get(key) instanceof List); } }
@MapFeature.Require(SUPPORTS_REMOVE) public void testAsMapRemoveImplementsList() { List<K> keys = new ArrayList<>(multimap().keySet()); for (K key : keys) { resetCollection(); assertTrue(multimap().asMap().remove(key) instanceof List); } }
protected void assertGet(K key, Collection<V> values) { assertEqualInOrder(values, multimap().get(key)); if (!values.isEmpty()) { assertEqualInOrder(values, multimap().asMap().get(key)); assertFalse(multimap().isEmpty()); } else { assertNull(multimap().asMap().get(key)); } assertEquals(values.size(), multimap().get(key).size()); assertEquals(values.size() > 0, multimap().containsKey(key)); assertEquals(values.size() > 0, multimap().keySet().contains(key)); assertEquals(values.size() > 0, multimap().keys().contains(key)); } }
@Override public Enumeration<String> getHeaders(String name) { for (Map.Entry<String, Collection<String>> entry : headers.asMap().entrySet()) { if (entry.getKey().equalsIgnoreCase(name)) { return enumeration(entry.getValue()); } } return emptyEnumeration(); }
@Override protected Map<String, Collection<Integer>> makeEmptyMap() { return Multimaps.transformValues( ArrayListMultimap.<String, Integer>create(), Functions.<Integer>identity()) .asMap(); }
public void testAsMap_listMultimap() { ListMultimap<String, Integer> listMultimap = ArrayListMultimap.create(); Map<String, List<Integer>> map = Multimaps.asMap(listMultimap); assertSame(listMultimap.asMap(), map); }
@Override protected Map<String, Collection<Integer>> makePopulatedMap() { ListMultimap<String, Integer> delegate = ArrayListMultimap.create(); populate(delegate); return Multimaps.transformValues(delegate, Functions.<Integer>identity()).asMap(); } }
@CollectionSize.Require(SEVERAL) @MapFeature.Require(SUPPORTS_REMOVE) public void testValuesRemove() { resetContainer( Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k1(), v0()), Helpers.mapEntry(k0(), v3())); assertTrue(multimap().asMap().values().remove(Collections.singletonList(v0()))); assertEquals(2, multimap().size()); assertEquals( Collections.singletonMap(k0(), Lists.newArrayList(v0(), v3())), multimap().asMap()); } }
@SuppressWarnings("unchecked") @MapFeature.Require(SUPPORTS_REMOVE) @CollectionSize.Require(SEVERAL) public void testRemoveAtIndexFromAsMapEntrySetPropagates() { List<V> values = Arrays.asList(v0(), v1(), v0()); for (int i = 0; i < 3; i++) { resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k0(), v0())); List<V> expectedValues = copyToList(values); Entry<K, Collection<V>> asMapEntry = multimap().asMap().entrySet().iterator().next(); List<V> asMapValue = (List<V>) asMapEntry.getValue(); asMapValue.remove(i); expectedValues.remove(i); assertGet(k0(), expectedValues); } } }
@CollectionSize.Require(SEVERAL) public void testEntrySetEquals() { resetContainer( Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k1(), v0()), Helpers.mapEntry(k0(), v3())); Set<Entry<K, Collection<V>>> expected = Sets.newHashSet(); expected.add(Helpers.mapEntry(k0(), (Collection<V>) Lists.newArrayList(v0(), v3()))); expected.add(Helpers.mapEntry(k1(), (Collection<V>) Lists.newArrayList(v0()))); new EqualsTester().addEqualityGroup(expected, multimap().asMap().entrySet()).testEquals(); }
@CollectionSize.Require(SEVERAL) public void testEquals() { resetContainer( Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k1(), v0()), Helpers.mapEntry(k0(), v3())); Map<K, Collection<V>> expected = Maps.newHashMap(); expected.put(k0(), Lists.newArrayList(v0(), v3())); expected.put(k1(), Lists.newArrayList(v0())); new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals(); }
@SuppressWarnings("unchecked") @MapFeature.Require(SUPPORTS_REMOVE) @CollectionSize.Require(SEVERAL) public void testRemoveAtIndexFromAsMapPropagates() { List<V> values = Arrays.asList(v0(), v1(), v0()); for (int i = 0; i < 3; i++) { resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k0(), v0())); List<V> expectedValues = copyToList(values); List<V> asMapValue = (List<V>) multimap().asMap().get(k0()); asMapValue.remove(i); expectedValues.remove(i); assertGet(k0(), expectedValues); } }
public void testNewListMultimap() { CountingSupplier<LinkedList<Integer>> factory = new ListSupplier(); Map<Color, Collection<Integer>> map = Maps.newTreeMap(); ListMultimap<Color, Integer> multimap = Multimaps.newListMultimap(map, factory); assertEquals(0, factory.count); multimap.putAll(Color.BLUE, asList(3, 1, 4, 1)); assertEquals(1, factory.count); multimap.putAll(Color.RED, asList(2, 7, 1, 8)); assertEquals(2, factory.count); assertEquals("{BLUE=[3, 1, 4, 1], RED=[2, 7, 1, 8]}", multimap.toString()); assertFalse(multimap.get(Color.BLUE) instanceof RandomAccess); assertTrue(multimap.keySet() instanceof SortedSet); assertTrue(multimap.asMap() instanceof SortedMap); }
public void testTreeKeys_gwtCompatible() { ListMultimap<String, Integer> multimap = MultimapBuilder.treeKeys().arrayListValues().<String, Integer>build(); assertTrue(multimap.keySet() instanceof SortedSet); assertTrue(multimap.asMap() instanceof SortedMap); }
@GwtIncompatible // doesn't build without explicit type parameters on build() methods public void testTreeKeys() { ListMultimap<String, Integer> multimap = MultimapBuilder.treeKeys().arrayListValues().build(); assertTrue(multimap.keySet() instanceof SortedSet); assertTrue(multimap.asMap() instanceof SortedMap); }