public void add(String name, String value) { delegate.put(name, value); }
/** Test throwing ConcurrentModificationException when a sublist's ancestor's delegate changes. */ public void testSublistConcurrentModificationException() { ListMultimap<String, Integer> multimap = create(); multimap.putAll("foo", asList(1, 2, 3, 4, 5)); List<Integer> list = multimap.get("foo"); assertThat(multimap.get("foo")).containsExactly(1, 2, 3, 4, 5).inOrder(); List<Integer> sublist = list.subList(0, 5); assertThat(sublist).containsExactly(1, 2, 3, 4, 5).inOrder(); sublist.clear(); assertTrue(sublist.isEmpty()); multimap.put("foo", 6); try { sublist.isEmpty(); fail("Expected ConcurrentModificationException"); } catch (ConcurrentModificationException expected) { } }
/** * Replace any/all entries with this key, with this single entry. * * @param name * @param value */ public void set(String name, String value) { delegate.removeAll(name); delegate.put(name, value); }
public void add(String name, String value) { delegate.put(name, value); }
@Override protected ListMultimap<String, String> create(Entry<String, String>[] entries) { ListMultimap<String, String> multimap = ArrayListMultimap.create(); for (Entry<String, String> entry : entries) { multimap.put(entry.getKey(), entry.getValue()); } return multimap; } })
@Override ListMultimap<String, Integer> filter(ListMultimap<String, Integer> multimap) { multimap.put("foo", 17); multimap.put("bar", 32); multimap.put("foo", 16); multimap = Multimaps.filterKeys(multimap, Predicates.not(Predicates.equalTo("foo"))); return Multimaps.filterKeys( multimap, Predicates.not(Predicates.equalTo("bar"))); } })
@Override protected ListMultimap<String, String> create(Entry<String, String>[] entries) { ListMultimap<String, String> multimap = Multimaps.synchronizedListMultimap( ArrayListMultimap.<String, String>create()); for (Entry<String, String> entry : entries) { multimap.put(entry.getKey(), entry.getValue()); } return multimap; } })
@Override protected ListMultimap<String, String> create(Entry<String, String>[] entries) { ListMultimap<String, String> multimap = LinkedListMultimap.create(); for (Entry<String, String> entry : entries) { multimap.put(entry.getKey(), entry.getValue()); } return multimap; } })
public void testLinkedGetInsert() { ListMultimap<String, Integer> map = create(); map.put("bar", 1); List<Integer> foos = map.get("foo"); foos.add(2); foos.add(0, 3); map.put("bar", 4); map.put("foo", 5); assertEquals("{bar=[1, 4], foo=[3, 2, 5]}", map.toString()); assertEquals("[bar=1, foo=3, foo=2, bar=4, foo=5]", map.entries().toString()); }
public void testSynchronizedArrayListMultimapRandomAccess() { ListMultimap<String, Integer> delegate = ArrayListMultimap.create(); delegate.put("foo", 1); delegate.put("foo", 3); ListMultimap<String, Integer> multimap = Multimaps.synchronizedListMultimap(delegate); assertTrue(multimap.get("foo") instanceof RandomAccess); assertTrue(multimap.get("bar") instanceof RandomAccess); }
public void testUnmodifiableArrayListMultimapRandomAccess() { ListMultimap<String, Integer> delegate = ArrayListMultimap.create(); delegate.put("foo", 1); delegate.put("foo", 3); ListMultimap<String, Integer> multimap = Multimaps.unmodifiableListMultimap(delegate); assertTrue(multimap.get("foo") instanceof RandomAccess); assertTrue(multimap.get("bar") instanceof RandomAccess); }
@Override public ListMultimap<String, Integer> create(Object... elements) { ListMultimap<String, Integer> multimap = LinkedListMultimap.create(); for (Object o : elements) { @SuppressWarnings("unchecked") Entry<String, Integer> entry = (Entry<String, Integer>) o; multimap.put(entry.getKey(), entry.getValue()); } return filter(multimap); }
public void testSynchronizedLinkedListMultimapRandomAccess() { ListMultimap<String, Integer> delegate = LinkedListMultimap.create(); delegate.put("foo", 1); delegate.put("foo", 3); ListMultimap<String, Integer> multimap = Multimaps.synchronizedListMultimap(delegate); assertFalse(multimap.get("foo") instanceof RandomAccess); assertFalse(multimap.get("bar") instanceof RandomAccess); } }
public void testUnmodifiableLinkedListMultimapRandomAccess() { ListMultimap<String, Integer> delegate = LinkedListMultimap.create(); delegate.put("foo", 1); delegate.put("foo", 3); ListMultimap<String, Integer> multimap = Multimaps.unmodifiableListMultimap(delegate); assertFalse(multimap.get("foo") instanceof RandomAccess); assertFalse(multimap.get("bar") instanceof RandomAccess); }
/** * Replace any/all entries with this key, with this single entry. * * @param name * @param value */ public void set(String name, String value) { delegate.removeAll(name); delegate.put(name, value); }
@MapFeature.Require(SUPPORTS_PUT) public void testPutAddsValueAtEnd() { for (K key : sampleKeys()) { for (V value : sampleValues()) { resetContainer(); List<V> values = multimap().get(key); List<V> expectedValues = Helpers.copyToList(values); assertTrue(multimap().put(key, value)); expectedValues.add(value); assertGet(key, expectedValues); assertEquals(value, values.get(values.size() - 1)); } } }
@MapFeature.Require(SUPPORTS_PUT) @CollectionSize.Require(absent = ZERO) public void testPutDuplicateValue() { List<Entry<K, V>> entries = copyToList(multimap().entries()); for (Entry<K, V> entry : entries) { resetContainer(); K k = entry.getKey(); V v = entry.getValue(); List<V> values = multimap().get(k); List<V> expectedValues = copyToList(values); assertTrue(multimap().put(k, v)); expectedValues.add(v); assertGet(k, expectedValues); assertEquals(v, values.get(values.size() - 1)); } } }
public void testLinkedClear() { ListMultimap<String, Integer> map = create(); map.put("foo", 1); map.put("foo", 2); map.put("bar", 3); List<Integer> foos = map.get("foo"); Collection<Integer> values = map.values(); assertEquals(asList(1, 2), foos); assertThat(values).containsExactly(1, 2, 3).inOrder(); map.clear(); assertEquals(Collections.emptyList(), foos); assertThat(values).isEmpty(); assertEquals("[]", map.entries().toString()); assertEquals("{}", map.toString()); }
public void testEntriesAfterMultimapUpdate() { ListMultimap<String, Integer> multimap = create(); multimap.put("foo", 2); multimap.put("bar", 3); Collection<Entry<String, Integer>> entries = multimap.entries(); Iterator<Entry<String, Integer>> iterator = entries.iterator(); Entry<String, Integer> entrya = iterator.next(); Entry<String, Integer> entryb = iterator.next(); assertEquals(2, (int) multimap.get("foo").set(0, 4)); assertFalse(multimap.containsEntry("foo", 2)); assertTrue(multimap.containsEntry("foo", 4)); assertTrue(multimap.containsEntry("bar", 3)); assertEquals(4, (int) entrya.getValue()); assertEquals(3, (int) entryb.getValue()); assertTrue(multimap.put("foo", 5)); assertTrue(multimap.containsEntry("foo", 5)); assertTrue(multimap.containsEntry("foo", 4)); assertTrue(multimap.containsEntry("bar", 3)); assertEquals(4, (int) entrya.getValue()); assertEquals(3, (int) entryb.getValue()); }