*/
    void enqueue(Runnable task);

    /**
     * Runs the given action, blocking until the result is available.
     *

    }

    @Override
    List<BuildOperationRecord> all() {
        return operations.records.values().toList()
    }

    @Override
    List<BuildOperationRecord> all(Pattern displayName) {
        return operations.records.values().findAll { it.displayName ==~ displayName }
    }

    @Override
    BuildOperationRecord only(Pattern displayName) {
        def records = all(displayName)
        if (records.isEmpty()) {

/**
 * The outputs of a graph resolution. All results on this type are lazy. Resolution is only performed
 * when the results are accessed.
 *
 * TODO: This type is intended to be made public in future Gradle versions, in some form.
 */
@HasInternalProtocol
public interface ResolutionOutputs {

    /**
     * A {@link FileCollection} containing all resolved files. The returned collection

         *
         * Because of it doing so, our decorated call site is removed from the dynamic invocation code path, and we lose the ability to track dynamic call entry points. <p>
         *
         * To fix that, we store the optimized call site that the Groovy runtime created (and we delegate to it in subsequent calls), and we put a reference to our
         * decorated call site back into the call site array.
         */

<% projectDeps.each { p ->
  sourceFiles.times { %>
#include "${p}lib${it + 1}.h"
<%
  }
} %>

<% functionCount.times { %>
long CPP_${functionName}_${it + 1} () {
  long sum = 1;
  // Call functions defined in dependent projects.
  <% projectDeps.each { p ->
    sourceFiles.times {
      def functionName = "${p}lib${it + 1}"
      functionCount.times {
  %>
  sum += CPP_${functionName}_${it + 1}();
  <%

By default, `outgoingVariants` prints information about all variants.
It offers the optional parameter `--variant <variantName>` to select a single variant to display.
It also accepts the `--all` flag to include information about legacy and deprecated configurations, or `--no-all` to exclude this information.

        when:
        executer.withArgument("--continue")
        fails("broken1", "broken2", "broken3")

        then:
        failure.assertHasCause("Cannot call ${description} on task ':broken1' after task has started execution.")
        failure.assertHasCause("Cannot call ${description} on task ':broken2' after task has started execution.")

        where:
        config                                                      | description

        if (allServices.containsKey(serviceType)) {
            return Cast.uncheckedNonnullCast(allServices.get(serviceType));
        }
        List<T> all = delegate.getAll(serviceType);
        allServices.put(serviceType, all);
        return all;
    }

    @Override
    public synchronized <T> DefaultServiceLocator.ServiceFactory<T> getFactory(Class<T> serviceType) throws UnknownServiceException {

        this.strict = false;
        return this;
    }

    /**
     * Providing a scope makes the resulting {@link ServiceRegistry}
     * validate all registered services for being annotated with the given scope.
     * <p>
     * All registered services require the {@link org.gradle.internal.service.scopes.ServiceScope @ServiceScope}
     * annotation to be present and contain the given scope.
     *

    def "captures plugin application events"() {
        given:
        file("build.gradle") << "apply plugin: 'java'"

        when:
        succeeds "build"

        then:
        def plugins = operations.all(ApplyPluginBuildOperationType) {
            it.details.targetType == "project" &&
                it.details.targetPath == ":" &&
                it.details.buildPath == ":"
        }