}

bool HasDataDependencyWithUnscheduledOp(
    Operation& op, Block* block, SmallPtrSet<Operation*, 16>& unscheduled_ops) {
  WalkResult ready_to_schedule = op.walk([&](Operation* nested_op) {
    for (Value operand : nested_op->getOperands()) {
      Operation* defining_op = operand.getDefiningOp();
      if (!defining_op) continue;
      Operation* producer_in_block = block->findAncestorOpInBlock(*defining_op);

        return new IdentityContext(context, identityInputProperties, identityInputFileProperties, identity);
    }

    public interface Operation extends BuildOperationType<Operation.Details, Operation.Result> {
        interface Details {
            Class<?> getWorkType();
        }

        interface Result {
            Identity getIdentity();
        }
    }

import org.gradle.internal.operations.BuildOperationCategory;
import org.gradle.internal.operations.BuildOperationDescriptor;
import org.gradle.internal.operations.BuildOperationIdFactory;
import org.gradle.internal.operations.BuildOperationMetadata;
import org.gradle.internal.operations.BuildOperationRef;
import org.gradle.internal.operations.CurrentBuildOperationRef;

    val file = File(projectRoot, "operation-trace-log.txt")
    action(CompileTrace(file.readLines()))
}


internal
class CompileTrace(private val operations: List<String>) {

    fun assertScriptCompile(stage: CachedScript.CompilationStage) {
        val description = operationDescription(stage)
        require(operations.any { it.contains(description) }) {

    private
    val operations = mutableListOf<suspend WriteContext.() -> Unit>()

    suspend fun WriteContext.playback() {
        withBeanTrace(beanType) {
            operations.forEach { operation ->
                operation()
            }
        }
    }

    private
    fun record(operation: suspend WriteContext.() -> Unit) {
        operations.add(operation)
    }

        when:
        def operation1 = factory.newTemplateOperation()
        def operation2 = factory.newTemplateOperation()

        operation1.withBindings(key:"value")
        operation1.withTarget(new File("atarget"))

        then:
        operation1 != operation2
        operation1.bindings.size() == 4
        operation2.bindings.size() == 3
        operation2.target == null
    }

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

        operations.each { operation ->
            operationQueue.add(operation)
        }
        def failureCount = operations.findAll({ it instanceof Failure }).size()

        when:
        operationQueue.waitForCompletion()

        then:
        // assumes we don't fail early
        MultipleBuildOperationFailures e = thrown()
        e.getCauses().every({ it instanceof GradleException })

 * limitations under the License.
 */

package org.gradle.caching.internal.operations;

import org.gradle.internal.operations.BuildOperationType;

/**
 * A load operation from a build cache.
 *
 * A load operation may HIT or MISS.
 * It may also fail.
 * Load operation results and failures are mutually exclusive.
 */

import org.gradle.internal.code.UserCodeApplicationContext;
import org.gradle.internal.code.UserCodeApplicationId;
import org.gradle.internal.operations.BuildOperationContext;
import org.gradle.internal.operations.BuildOperationDescriptor;
import org.gradle.internal.operations.BuildOperationRunner;
import org.gradle.internal.operations.RunnableBuildOperation;

import javax.annotation.Nullable;