dirty = false
    }

    protected Operation newOperation(StartEvent startEvent, Operation parent, OperationDescriptor descriptor) {
        new Operation(startEvent, parent, descriptor)
    }

    protected void otherEvent(ProgressEvent event, Operation operation) {
        throw new AssertionError("Unexpected type of progress event received: ${event.getClass()}")

        operations * operation.run(_)

        where:
        // Where operations < maxThreads
        // operations = maxThreads
        // operations >> maxThreads
        operations | maxThreads
        0          | 1
        1          | 1
        20         | 1
        1          | 4
        4          | 4
        20         | 4
    }

        for (Operation operation : operations.values()) {
            operation.completeHeader();
        }
        listener.onOutput(event);
    }

    private void onComplete(ProgressCompleteEvent progressCompleteEvent) {
        if (operations.isEmpty()) {
            return;
        }
        Operation operation = operations.remove(progressCompleteEvent.getProgressOperationId());

    }

  // Sort matched operations by their position in the block.
  llvm::sort(cluster.operations, [](Operation *a, Operation *b) -> bool {
    return a->isBeforeInBlock(b);
  });

  // Create tf_device::ClusterOp before the last operation in the block that
  // is a part of a match set.
  auto back = cluster.operations.back();
  auto loc = back->getLoc();
  OpBuilder builder(back);

        }

        then:
        events.operations.size() == 3
        events.trees == events.operations
        events.operations.every { it.successful }
        events.operation("Download ${projectFModuleMissing.pom.uri}").assertIsDownload(projectFModuleMissing.pom)
        events.operation("Download ${projectF2.pom.uri}").assertIsDownload(projectF2.pom)

        private final long time
        private final BuildOperationRecord operation

        TimePoint(BuildOperationRecord operation, long time) {
            this(operation, time, false)
        }

        TimePoint(BuildOperationRecord operation, long time, boolean end) {
            this.operation = operation
            this.time = time
            this.end = end
        }

        @Override

    <T> T call(CallableBuildOperation<T> buildOperation);

    /**
     * Starts an operation that can be finished later.
     *
     * When a parent operation is finished any unfinished child operations will be failed.
     */
    BuildOperationContext start(BuildOperationDescriptor.Builder descriptor);

    /**
     * Executes the given build operation with the given worker, returns the result.
     */

        }

        buildFile << """
            import org.gradle.internal.operations.BuildOperationExecutor
            import org.gradle.internal.operations.RunnableBuildOperation
            import org.gradle.internal.operations.BuildOperationContext
            import org.gradle.internal.operations.BuildOperationDescriptor
            import java.util.concurrent.CountDownLatch

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

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

      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