details == 'Gradle cannot track the implementation for classes loaded with an unknown classloader.'
            solutions == [ 'Load your class by using one of Gradle\'s built-in ways.' ]
            additionalData.asMap == [
                'typeName' : 'CustomTask'
            ]
        }
        verifyAll(receivedProblem(1)) {
            fqid == 'validation:property-validation:unknown-implementation'

		}
	}

	return caMap, nil
}

// Certificates is a list of Certificates that Kubeadm should create.
type Certificates []*KubeadmCert

// AsMap returns the list of certificates as a map, keyed by name.
func (c Certificates) AsMap() CertificateMap {
	certMap := make(map[string]*KubeadmCert)
	for _, cert := range c {
		certMap[cert.Name] = cert
	}

	return certMap
}

    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> putAll(Multimap<? extends K, ? extends V> multimap) {
      for (Entry<? extends K, ? extends Collection<? extends V>> entry :
          multimap.asMap().entrySet()) {
        putAll(entry.getKey(), entry.getValue());
      }
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    Builder<K, V> combine(ImmutableMultimap.Builder<K, V> other) {

            solutions == [
                "Use a $fileType as an input",
                "Declare the input as a ${getOppositeKind(fileType)} instead",
            ].collect { it.toString() }
            additionalData.asMap == [
                'typeName': 'org.gradle.api.DefaultTask',
                'propertyName': 'input',
            ]
        }

        where:
        method | path             | fileType

            formatter.node("Cannot choose between the available variants of ");
        } else {
            String node = "The consumer was configured to find " + describer.describeAttributeSet(failure.getRequestedAttributes().asMap());
            if (listAvailableVariants) {
                node = node + ". However we cannot choose between the following variants of ";
            } else {

        } else {
            formatter.node("No matching variant of " + targetVariantText + " was found. The consumer was configured to find " + describer.describeAttributeSet(failure.getRequestedAttributes().asMap()) + " but:");
        }

        formatter.startChildren();
        switch (failureSubType) {
            case NO_VARIANTS_EXIST:
                formatter.node("No variants exist.");
                break;

  }

  /**
   * Returns an immutable multimap containing the same mappings as {@code multimap}. The generated
   * multimap's key and value orderings correspond to the iteration ordering of the {@code
   * multimap.asMap()} view.
   *
   * <p>Despite the method name, this method attempts to avoid actually copying the data when it is
   * safe to do so. The exact circumstances under which a copy will or will not be performed are

		}
	}

	if !bytes.Equal(sum, c.Raw) {
		return ChecksumMismatch{
			Want: c.Encoded,
			Got:  base64.StdEncoding.EncodeToString(sum),
		}
	}
	return nil
}

// AsMap returns the
func (c *Checksum) AsMap() map[string]string {
	if c == nil || !c.Valid() {
		return nil
	}
	return map[string]string{c.Type.String(): c.Encoded}
}

        });
        seenProblems.clear();
    }

    private List<InternalProblemAggregationVersion3> createSummaries() {
        return seenProblems.asMap().values()
            .stream()
            .map(ImmutableList::copyOf)
            .filter(values -> values.size() > 1)
            .map(AggregatingProblemConsumer::createProblemAggregation)

                    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 {}'