ProjectLock(MavenSession session, MojoDescriptor mojoDescriptor) {
            mojos.put(Thread.currentThread(), mojoDescriptor);
            boolean aggregator = mojoDescriptor.isAggregator();
            acquiredAggregatorLock = aggregator ? aggregatorLock.writeLock() : aggregatorLock.readLock();
            acquiredProjectLock = getProjectLock(session);
            if (!acquiredAggregatorLock.tryLock()) {

        if (requiresReports != null) {
            mojo.setRequiresReports(Boolean.parseBoolean(requiresReports));
        }

        String aggregator = c.getChild("aggregator").getValue();

        if (aggregator != null) {
            mojo.setAggregator(Boolean.parseBoolean(aggregator));
        }

        String requiresOnline = c.getChild("requiresOnline").getValue();

        if (requiresOnline != null) {

                scenario("Selected aggregator project (including child modules)")
                        .activeRequiredProjects(MODULE_C)
                        .expectResult(MODULE_C, MODULE_C_1, MODULE_C_2),
                scenario("Selected aggregator project with non-recursive")
                        .activeRequiredProjects(MODULE_C)

    }

    @Test
    void testInvalidAggregatorPackaging() throws Exception {
        SimpleProblemCollector result = validate("invalid-aggregator-packaging-pom.xml");

        assertViolations(result, 0, 1, 0);

        assertTrue(result.getErrors().get(0).contains("Aggregator projects require 'pom' as packaging."));
    }

    @Test
    void testMissingDependencyArtifactId() throws Exception {

          <defaultValue>false</defaultValue>
        </field>
        <field>
          <name>aggregator</name>
          <version>1.0.0+</version>
          <type>boolean</type>
          <description>
            Flags this Mojo to run it in a multi-module way, i.e. aggregate the build with the set of projects
            listed as modules.
          </description>

                        Severity.ERROR,
                        Version.BASE,
                        "packaging",
                        null,
                        "with value '" + m.getPackaging() + "' is invalid. Aggregator projects "
                                + "require 'pom' as packaging.",
                        m);
            }

            for (int i = 0, n = m.getModules().size(); i < n; i++) {

}

// IsAggregated returns if the statement involves SQL aggregation
func (e *SelectStatement) IsAggregated() bool {
	return e.selectQProp.isAggregation
}

// AggregateResult - returns the aggregated result after all input
// records have been processed. Applies only to aggregation queries.
func (e *SelectStatement) AggregateResult(output Record) error {

        if (aggregations != null) {
            aggregations.forEach(aggregation -> {
                if (aggregation.getName().startsWith(Constants.FACET_FIELD_PREFIX)) {
                    final Terms termFacet = (Terms) aggregation;
                    fieldList.add(new Field(termFacet));
                } else if (aggregation.getName().startsWith(Constants.FACET_QUERY_PREFIX)) {

plugins {
    id("base")
}

val reports by configurations.creating {
    isCanBeResolved = false
    isCanBeConsumed = false
    description = "Dependencies to aggregate reports from"
}

val allIncubationReports = tasks.register<IncubatingApiAggregateReportTask>("allIncubationReports") {
    group = "verification"
    reports.from(resolver("txt"))

            assertTrue(result.success(), "Orchestrator should succeed");
            assertEquals(2, result.processedPoms().size(), "Should aggregate processed POMs");
            assertEquals(2, result.modifiedPoms().size(), "Should aggregate modified POMs");
            assertEquals(0, result.errorPoms().size(), "Should have no errors");
        }

        @Test