`test` - Task (lifecycle)::
Depends on: `runTest__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`.

is not acceptable.

Frequency:

Vet is run every day by many programmers, often as part of every compilation or
submission. The cost in execution time is considerable, especially in aggregate,
so checks must be likely enough to find real problems that they are worth the
overhead of the added check. A new check that finds only a handful of problems

import javax.annotation.Nullable;
import java.util.List;

/**
 * Fetches models for given projects in an Isolated Project-compatible manner.
 * <p>
 * It should be used by tooling model builders when they need to aggregate models
 * from <b>multiple projects of the same build</b>.
 */
@NonNullApi
@ServiceScope(Scope.Build.class)
public interface IntermediateToolingModelProvider {

    /**

    @Nonnull
    RemoteRepository createRemote(@Nonnull String id, @Nonnull String url);

    @Nonnull
    RemoteRepository createRemote(@Nonnull Repository repository);

    @Nonnull
    List<RemoteRepository> aggregate(
            @Nonnull Session session,
            @Nonnull List<RemoteRepository> dominant,
            @Nonnull List<RemoteRepository> recessive,
            boolean processRecessive);

====

Applying the plugin adds the `buildDashboard` task to your project. The task aggregates the reports for all tasks that implement the link:{groovyDslPath}/org.gradle.api.reporting.Reporting.html[Reporting] interface from _all projects_ in the build. It is typically only applied to the root project.

        // 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 {

`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.

					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.
 *

	FailOnError bool
}

// New returns a token authenticator that validates credentials using a chain of authenticator.Token objects.
// The entire chain is tried until one succeeds. If all fail, an aggregate error is returned.
func New(authTokenHandlers ...authenticator.Token) authenticator.Token {
	if len(authTokenHandlers) == 1 {
		return authTokenHandlers[0]
	}