[(jsonChange.toApiChange()): jsonChange.acceptation]
            }
            acceptedApiChanges.acceptedChanges.putAll(acceptedChanges)
        }
        return acceptedApiChanges
    }

    Map<String, String> toAcceptedChangesMap() {
        acceptedChanges.collectEntries { change ->

        TestedVersions.asciidoctor.collectEntries([:]) { version ->
            def base = [
                "org.asciidoctor.editorconfig",
                "org.asciidoctor.js.convert",
                "org.asciidoctor.jvm.convert",
                "org.asciidoctor.jvm.epub",
                "org.asciidoctor.jvm.gems",
                "org.asciidoctor.jvm.pdf",
            ].collectEntries { plugin ->

        public void collectInto(ImmutableCollection.Builder<T> builder) {
            collectEntries(ValueConsumer.IgnoreUnsafeRead, valueCollector, builder);
        }

        @Override
        public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> dest) {
            return delegate.collectEntries(consumer, collector, dest);
        }

        @Override

            output.findAll(">>> .*").collect {it.takeAfter(">>> ").split("=") }.collectEntries()

        configurationsWithAttribute ==
            ["buildScriptClasspath", "compileClasspath", "runtimeClasspath", "testCompileClasspath", "testRuntimeClasspath", "otherCompileClasspath", "otherRuntimeClasspath"]
                .collectEntries { [it, GradleVersion.current().getVersion()] }
    }

        configurationCacheRun ":consumer:resolve"
        then:
        uniqueIdsPerColor == uniqueIdsFromStore
    }

    private Map<String, Long> getUniqueIdsPerColor() {
        transformStepIdentities.collectEntries { color, identities ->
            def nodeIds = (identities*.transformStepNodeId as Set<Long>)
            [(color): Iterables.getOnlyElement(nodeIds)]
        }
    }

        }

        @Override
        public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
            Value<Void> leftValue = left.collectEntries(consumer, collector, dest);
            if (leftValue.isMissing()) {
                return leftValue;
            }
            Value<Void> rightValue = right.collectEntries(consumer, collector, dest);
            if (rightValue.isMissing()) {

        @Override
        public Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> dest) {
            Value<Void> leftValue = left.collectEntries(consumer, collector, dest);
            if (leftValue.isMissing()) {
                return leftValue;
            }
            Value<Void> rightValue = right.collectEntries(consumer, collector, dest);

    @Override
    void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        Map<String, String> entries = request.getHeaderNames().toList().collectEntries { headerName -> [headerName, request.getHeader(headerName as String)] }
        allHeaders.add(entries)
        String authorization = getAuthorizationHeader(request)
        if (authorization != null) {

class NamedDomainObjectCollectionSchemaIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        buildFile """
            def extractSchema(container) {
                return container.collectionSchema.elements.collectEntries { e ->
                    [ e.name, e.publicType.simpleName ]
                }.sort()
            }
            def assertSchemaIs(Map expected, NamedDomainObjectCollection container) {

        fails "validatePlugins"
        def report = new TaskValidationReportFixture(file("build/reports/plugin-development/validation-report.json"))
        report.verify(messages.collectEntries {
            def fullMessage = it.message
            if (!it.defaultDocLink) {
                fullMessage = "${fullMessage}\n${learnAt(it.id, it.section)}"
            }
            [(fullMessage): it.severity]