[(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 ->

        }

        @Override
        public MapCollector<K, V> absentIgnoring() {
            // always present
            return this;
        }

        @Override
        public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
            collector.add(key, value, dest);
            return Value.present();
        }

        @Override

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

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

def jdkVariables = ["JDK_8", "JDK_11", "JDK_17"]
def jdkLocations = jdkVariables.findAll { v ->
    System.getenv(v) != null
}.collectEntries { v ->
    [v, System.getenv(v)]

        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)]
        }
    }

    }

    private static Map diff(List<String> previous, List<String> current) {
        SortedMap<String, String> previousMap = ImmutableSortedMap.copyOf(previous.collectEntries { [(it): 'previous' + it] })
        SortedMap<String, String> currentMap = ImmutableSortedMap.copyOf(current.collectEntries { [(it): 'current' + it] })

        Map result = [added: [], removed: [], updated: []]

            assert request.testClassNames == []
            assert request.testExecutionDescriptors == []
            assert request.taskAndTests.collectEntries { [it.key, it.value.collect { r -> r.className }] } == ["test" : ["clazz1", "clazz2"]]
        }
    }

    def "test method requests with specific task added to test request"() {
        given:

        forkOptions.tempDir == null
        forkOptions.jvmArgs == []
    }

    def 'options can be defined via a map'() {
        when:
        forkOptions.define(PROPS.collectEntries { [it, "${it}Value" as String ] })
        then:
        PROPS.each { assert forkOptions."${it}" == "${it}Value" as String }
    }

 * <p>
 *     A <code>Collector</code> represents an increment to a collection property.
 * </p>
 */
public interface Collector<T> extends ValueSupplier {
    Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> dest);

    int size();

    void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor);