}
        return entries;
      }
    }

    @Override
    public Map<K, Collection<V>> asMap() {
      synchronized (mutex) {
        if (asMap == null) {
          asMap = new SynchronizedAsMap<>(delegate().asMap(), mutex);
        }
        return asMap;
      }
    }

    @Override
    public Multiset<K> keys() {
      synchronized (mutex) {

        delegate().forEach(action);
      }
    }

    @Override
    public Map<K, Collection<V>> asMap() {
      synchronized (mutex) {
        if (asMap == null) {
          asMap = new SynchronizedAsMap<>(delegate().asMap(), mutex);
        }
        return asMap;
      }
    }

    @Override
    public Multiset<K> keys() {
      synchronized (mutex) {

 * {@link #replaceValues} attempts to preserve iteration order as much as possible.
 *
 * <p>The collections returned by {@link #keySet()} and {@link #asMap} iterate through the keys in
 * the order they were first added to the multimap. Similarly, {@link #get}, {@link #removeAll}, and
 * {@link #replaceValues} return collections that iterate through the values in the order they were

 * {@link #replaceValues} attempts to preserve iteration order as much as possible.
 *
 * <p>The collections returned by {@link #keySet()} and {@link #asMap} iterate through the keys in
 * the order they were first added to the multimap. Similarly, {@link #get}, {@link #removeAll}, and
 * {@link #replaceValues} return collections that iterate through the values in the order they were

        Integer value = Iterables.getOnlyElement(entry.getValue());
        builder.put(entry.getKey(), value);
      }
      return builder.buildOrThrow().asMultimap().asMap();
    }

    @Override
    @SuppressWarnings({"unchecked", "rawtypes"}) // needed for arrays
    public Entry<String, Collection<Integer>>[] createArray(int length) {
      return new Entry[length];
    }

                    it.put('key','value')
                }
            }
        """

        when:
        run('reportProblem')

        then:
        receivedProblem.additionalData.asMap == ['key': 'value']
    }

    def "cannot emit a problem with invalid additional data"() {
        given:
        buildScript 'class InvalidData implements org.gradle.api.problems.internal.AdditionalData {}'

        this.entriesToBeWritten = entriesToBeWritten;
    }

    public void performPgpKeyGrouping() {
        Multimap<String, PgpEntry> keysToEntries = groupEntriesByPgpKey();
        keysToEntries.asMap()
            .entrySet()
            .forEach(e -> {
                // Filter out anything for which we have a trusted key entry already
                Collection<PgpEntry> pgpKeys = e.getValue().stream()

        Integer value = Iterables.getOnlyElement(entry.getValue());
        builder.put(entry.getKey(), value);
      }
      return builder.buildOrThrow().asMultimap().asMap();
    }

    @Override
    @SuppressWarnings({"unchecked", "rawtypes"}) // needed for arrays
    public Entry<String, Collection<Integer>>[] createArray(int length) {
      return new Entry[length];
    }

    override fun retainAll(elements: Collection<Task>): Boolean =
        delegate.retainAll(elements)

    override fun getAsMap(): SortedMap<String, Task> =
        delegate.asMap

    override fun getNames(): SortedSet<String> =
        delegate.names

    override fun getAt(name: String): Task =
        delegate.getAt(name)

    override val size: Int

            @Override
            public Iterable<? extends NamedDomainObjectSchema> getElements() {
                return Iterables.concat(
                    Iterables.transform(index.asMap().entrySet(), new Function<Map.Entry<String, T>, NamedDomainObjectSchema>() {
                        @Override
                        public NamedDomainObjectSchema apply(final Map.Entry<String, T> e) {