void addActions(String issueKey, Iterable<String> actions) { actionsByIssueKey.putAll(issueKey, actions); }
void addTransitions(String issueKey, List<Transition> transitions) { transitionsByIssueKey.putAll(issueKey, transitions); }
private ContextException addContext(ContextException e) { this.context.putAll(e.context); return this; }
final <T> void addSampleInstances(Class<T> type, Iterable<? extends T> instances) { sampleInstances.putAll(checkNotNull(type), checkNotNull(instances)); }
private DefaultParameters setValue(String key, String value) { checkArgument(!isNullOrEmpty(key)); checkArgument(value != null); keyValues.putAll(key, singletonList(value)); return this; }
public Builder addRelations(String parentQualifier, String... childrenQualifiers) { requireNonNull(parentQualifier); requireNonNull(childrenQualifiers); checkArgument(childrenQualifiers.length > 0, "childrenQualifiers can't be empty"); relations.putAll(parentQualifier, Arrays.asList(childrenQualifiers)); return this; }
@Override protected HttpQueryParams clone() { HttpQueryParams copy = new HttpQueryParams(); copy.delegate.putAll(this.delegate); return copy; }
private DefaultParameters setValues(String key, Collection<String> values) { checkArgument(!isNullOrEmpty(key)); checkArgument(values != null && !values.isEmpty()); this.keyValues.putAll(key, values.stream().map(Object::toString).filter(Objects::nonNull).collect(Collectors.toList())); return this; } }
public FakeRequest setMultiParam(String key, List<String> values) { multiParams.putAll(key, values); return this; }
/** * Sets this BindsConfig to be identical to other * * @param other The BindsConfig to copy */ public void setBinds(BindsConfig other) { uriBoundInputs.clear(); uriBoundInputs.putAll(other.uriBoundInputs); }
public void recordSubqueries(Node node, ExpressionAnalysis expressionAnalysis) { NodeRef<Node> key = NodeRef.of(node); this.inPredicatesSubqueries.putAll(key, dereference(expressionAnalysis.getSubqueryInPredicates())); this.scalarSubqueries.putAll(key, dereference(expressionAnalysis.getScalarSubqueries())); this.existsSubqueries.putAll(key, dereference(expressionAnalysis.getExistsSubqueries())); this.quantifiedComparisonSubqueries.putAll(key, dereference(expressionAnalysis.getQuantifiedComparisons())); }
public TestRequest setMultiParam(String key, List<String> values) { requireNonNull(key); requireNonNull(values); multiParams.putAll(key, values); return this; }
@GwtIncompatible // SerializableTester public void testNewListMultimapSerialization() { CountingSupplier<LinkedList<Integer>> factory = new ListSupplier(); Map<Color, Collection<Integer>> map = Maps.newTreeMap(); ListMultimap<Color, Integer> multimap = Multimaps.newListMultimap(map, factory); multimap.putAll(Color.BLUE, asList(3, 1, 4, 1)); multimap.putAll(Color.RED, asList(2, 7, 1, 8)); SerializableTester.reserializeAndAssert(multimap); }
@Override protected HttpQueryParams clone() { HttpQueryParams copy = new HttpQueryParams(); copy.delegate.putAll(this.delegate); return copy; }
@MapFeature.Require(SUPPORTS_PUT) public void testPutAllAddsAtEndInOrder() { @SuppressWarnings("unchecked") List<V> values = Arrays.asList(v3(), v1(), v4()); for (K k : sampleKeys()) { resetContainer(); List<V> expectedValues = copyToList(multimap().get(k)); assertTrue(multimap().putAll(k, values)); expectedValues.addAll(values); assertGet(k, expectedValues); } } }
public void setIssues(int componentRef, DefaultIssue... issues) { Component component = treeRootHolder.getComponentByRef(componentRef); checkArgument(component != null, String.format("Component '%s' does not exists in the report ", componentRef)); this.issues.get(component).clear(); this.issues.putAll(component, asList(issues)); }
public void testSynchronizedListMultimap() { ListMultimap<String, Integer> multimap = Multimaps.synchronizedListMultimap(ArrayListMultimap.<String, Integer>create()); multimap.putAll("foo", Arrays.asList(3, -1, 2, 4, 1)); multimap.putAll("bar", Arrays.asList(1, 2, 3, 1)); assertThat(multimap.removeAll("foo")).containsExactly(3, -1, 2, 4, 1).inOrder(); assertFalse(multimap.containsKey("foo")); assertThat(multimap.replaceValues("bar", Arrays.asList(6, 5))) .containsExactly(1, 2, 3, 1) .inOrder(); assertThat(multimap.get("bar")).containsExactly(6, 5).inOrder(); }
/** 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) { } }
public void testFlatteningToMultimap() { Collector<String, ?, ListMultimap<Character, Character>> collector = Multimaps.flatteningToMultimap( str -> str.charAt(0), str -> str.substring(1).chars().mapToObj(c -> (char) c), MultimapBuilder.linkedHashKeys().arrayListValues()::build); BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence = Equivalence.equals() .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet())) .and(Equivalence.equals()); ListMultimap<Character, Character> empty = MultimapBuilder.linkedHashKeys().arrayListValues().build(); ListMultimap<Character, Character> filled = MultimapBuilder.linkedHashKeys().arrayListValues().build(); filled.putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a')); filled.putAll('a', Arrays.asList('p', 'p', 'l', 'e')); filled.putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't')); filled.putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's')); filled.putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y')); CollectorTester.of(collector, equivalence) .expectCollects(empty) .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry"); }
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); }