assert it.parentId == treeOperations.first().id
        }
        return buildOperations
    }

    private BuildOperationRecord operation() {
        def operations = operations()
        assert operations.size() == 1
        return operations[0]
    }

            Operation operation = mapper.accept(buildOperation);
            if (operation != null) {
                Operation previous = running.put(buildOperation.getId(), operation);
                if (previous != null) {
                    throw new IllegalStateException("Operation " + buildOperation.getId() + " already started.");
                }
                operation.generateStartEvent(buildOperation, startEvent);

  const Block::iterator end = ops.end();

  // An operation is ready to be scheduled if all its operands are ready. An
  // operand is ready if:
  const auto is_ready = [&](Value value, Operation *top) {
    Operation *parent = value.getDefiningOp();
    // - it is a block argument,
    if (parent == nullptr) return true;
    Operation *ancestor = block->findAncestorOpInBlock(*parent);

        def runTasks = events.operation("Run tasks")
        runTasks.descriptor.name == "Run tasks"
        runTasks.descriptor.parent == runTasksParent.descriptor

        events.operations[0] == runBuild

        events.operations.every { it.successful }
        events.operations.every { it.buildOperation }
    }

    def "receive build progress events for failed operations"() {
        given:

      res.push_back(op.getValue());
    }
    return res;
  }

  // Gets a pointer to the operation to be folded.
  Operation* Op() { return operation_; }

 private:
  explicit FoldAdaptor(Operation* operation) : operation_(operation) {}
  Operation* const operation_;
};

// APSInt provides operators which APInt does not, so allow for converting

    ```

And all the ideas in the section about [adding `dependencies` to the *path operation decorators*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} still apply, but in this case, to all of the *path operations* in the app.

## Dependencies for groups of *path operations*

        0 * taskExecutionListener._
        0 * taskListener._

        and:
        buildOperationRunner.operations[0].name == ":a"
        buildOperationRunner.operations[0].displayName == "Task :a"
        buildOperationRunner.operations[0].progressDisplayName == ":a"
        buildOperationRunner.operations[0].metadata == BuildOperationCategory.TASK
    }

    def "does not run task action when beforeExecute event fails"() {

 * limitations under the License.
 */

package org.gradle.internal.execution.steps;

import org.gradle.internal.operations.BuildOperationContext;
import org.gradle.internal.operations.BuildOperationDescriptor;
import org.gradle.internal.operations.BuildOperationRunner;
import org.gradle.internal.operations.CallableBuildOperation;

import java.util.function.Function;

import org.gradle.caching.internal.controller.operations.LoadOperationDetails;
import org.gradle.caching.internal.controller.operations.LoadOperationHitResult;
import org.gradle.caching.internal.controller.operations.LoadOperationMissResult;
import org.gradle.caching.internal.controller.operations.StoreOperationDetails;
import org.gradle.caching.internal.controller.operations.StoreOperationResult;

            default:
                throw new AssertionError();
        }
    }

    /*
     * This operation is only used here temporarily. Should be replaced with a more stable operation in the long term.
     */
    public interface Operation extends BuildOperationType<Operation.Details, Operation.Result> {
        interface Details {
            Class<?> getWorkType();
            UnitOfWork.Identity getIdentity();