// run all tests with configuration caching
        file('gradle.properties') << 'org.gradle.configuration-cache=true'
    }

    @Issue('https://github.com/gradle/gradle/issues/26922')
    def 'can aggregate with `java-gradle-plugin` subproject'() {
        given:
        file('settings.gradle.kts') << """
            include(":plugin")
            dependencyResolutionManagement {

					return fmt.Errorf("inconsistent function %p: %d", f, f.ID)
				}
			}
		}
	}
	return nil
}

// Aggregate merges the locations in the profile into equivalence
// classes preserving the request attributes. It also updates the
// samples to point to the merged locations.
func (p *Profile) Aggregate(inlineFrame, function, filename, linenumber, address bool) error {
	for _, m := range p.Mapping {

 * A failed test, for instance, will cause a failing outcome for the test task, but this does not prevent another task
 * from reading and processing the (valid) test results output it produced (perhaps to aggregate multiple test reports).
 *
 * Verification failures do not represent a bug in either the build tool or custom task logic; the responsibility falls to the
 * project's software engineer to correct the verification failure.
 *

		}
		ropt.Symbol = s
	}

	rpt := report.New(p, ropt)
	if !relative {
		if err := applyFocus(p, numLabelUnits, cfg, o.UI); err != nil {
			return nil, nil, err
		}
	}
	if err := aggregate(p, cfg); err != nil {
		return nil, nil, err
	}

	return c, rpt, nil
}

// generateReport is allowed to modify p.

`test` - Task (lifecycle)::
Depends on: `xcTest__Variant__` that most closely matches the build host
::
Aggregate task of the variant that most closely match the build host for testing the component.

`check` - Task (lifecycle)::
Depends on: `test`
::
Aggregate task that performs verification tasks, such as running the tests.
Some plugins add their own verification task to `check`.

 * if some elements are too small, they will be aggregated by smallElementAggregateFunction.
 *
 * @param list the list to split, must be ordered by size desc
 * @param toIntFunction the function used to map the element to its "size"
 * @param largeElementSplitFunction the function used to further split the large element into smaller pieces
 * @param smallElementAggregateFunction the function used to aggregate tiny elements into a large bucket

import com.google.errorprone.annotations.concurrent.LazyInit;
import java.util.Collections;
import java.util.List;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/** Aggregate future that collects (stores) results of each future. */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
abstract class CollectionFuture<V extends @Nullable Object, C extends @Nullable Object>

// reads ServiceImport in the cluster in order to extract the ClusterSet VIP and generate a
// synthetic service for the MCS host (i.e. clusterset.local). The aggregate.Controller will then
// merge together the MCS services from all the clusters, filling out the full map of Cluster IPs.
//
// The synthetic MCS service is a copy of the real k8s Service (e.g. cluster.local) with the same

`assemble` - Task (lifecycle)::
Depends on: `linkDebug`
::
Aggregate task that assembles the debug variant of the application for the current host (if present) in the project.
This task is added by the <<base_plugin.adoc#base_plugin,Base Plugin>>.

`check` - Task (lifecycle)::
Aggregate task that performs verification tasks, such as running the tests.

// non-aggregate arguments or non-aggregate fields/elements of aggregate-typed
// arguments, along with special "operators". Specifically,
//   - for each non-aggregate arg/field/element, its offset from FP (1 byte) and
//     size (1 byte)
//   - special operators:
//   - 0xff - end of sequence
//   - 0xfe - print { (at the start of an aggregate-typed argument)