def lockManager = new DefaultFileLockManager(metaDataProvider, new NoOpFileLockContentionHandler())
    def buildOperationRunner = Stub(BuildOperationRunner) {
        run(_ as RunnableBuildOperation) >> { RunnableBuildOperation operation ->
            def context = Stub(BuildOperationContext)
            operation.run(context)
        }
    }

        BuildLifecycleController buildLifecycleController = getBuildController();
        ExceptionAnalyser exceptionAnalyser = buildScopeServices.get(ExceptionAnalyser.class);
        BuildOperationRunner buildOperationRunner = buildScopeServices.get(BuildOperationRunner.class);
        BuildStateRegistry buildStateRegistry = buildScopeServices.get(BuildStateRegistry.class);

    final buildOperationRunner = new TestBuildOperationRunner()

    final delegate = Mock(DeferredExecutionAwareStep)
    final work = Stub(UnitOfWork)

    def setup() {
        _ * work.displayName >> displayName
        _ * work.identify(_, _) >> identity
    }

    protected void assertNoOperation() {
        assert buildOperationRunner.log.records.empty
    }

    def projectConfigurer = Mock(ProjectConfigurer)
    def modelParameters = Mock(BuildModelParameters)
    def buildOperationRunner = Mock(BuildOperationRunner)
    def configurer = new DefaultProjectsPreparer(projectConfigurer, modelParameters, buildOperationRunner)

    def setup() {
        gradle.startParameter >> startParameter
        gradle.rootProject >> rootProject
    }

    def "configures build for standard mode"() {

        super(false, AgentStatus.disabled());
    }

    @Provides
    @Override
    protected CacheFactory createCacheFactory(FileLockManager fileLockManager, ExecutorFactory executorFactory, BuildOperationRunner buildOperationRunner) {
        return new TestInMemoryCacheFactory();
    }

    @Provides
    LoggingManagerInternal createLoggingManager(Factory<LoggingManagerInternal> loggingManagerFactory) {

    public TestBuildOperationExecutor() {
        this(new TestBuildOperationRunner());
    }

    public TestBuildOperationExecutor(TestBuildOperationRunner buildOperationRunner) {
        this.runner = buildOperationRunner;
        this.log = runner.log;
    }

    public List<BuildOperationDescriptor> getOperations() {
        return runner.getOperations();
    }

    @Override

class ProgressLoggingExternalResourceAccessorTest extends Specification {

    ExternalResourceAccessor delegate = Mock()
    BuildOperationRunner buildOperationRunner = Mock()
    BuildOperationContext context = Mock()
    ProgressLoggingExternalResourceAccessor accessor = new ProgressLoggingExternalResourceAccessor(delegate, buildOperationRunner)
    ExternalResourceMetaData metaData = Mock()
    ExternalResource.ContentAndMetadataAction action = Mock()

        File inputArtifact,
        TransformDependencies dependencies,
        TransformStepSubject subject,

        TransformExecutionListener transformExecutionListener,
        BuildOperationRunner buildOperationRunner,
        BuildOperationProgressEventEmitter progressEventEmitter,
        FileCollectionFactory fileCollectionFactory,
        InputFingerprinter inputFingerprinter,

    private final DeferredExecutionAwareStep<? super IdentityContext, R> delegate;

    public IdentifyStep(
        BuildOperationRunner buildOperationRunner,
        DeferredExecutionAwareStep<? super IdentityContext, R> delegate
    ) {
        super(buildOperationRunner);
        this.delegate = delegate;
    }

    @Override
    public R execute(UnitOfWork work, C context) {

        DependencyLockingProvider dependencyLockingProvider,
        Factory<ResolutionStrategyInternal> resolutionStrategyFactory,
        FileCollectionFactory fileCollectionFactory,
        BuildOperationRunner buildOperationRunner,
        Instantiator instantiator,
        NotationParser<Object, ConfigurablePublishArtifact> artifactNotationParser,
        NotationParser<Object, Capability> capabilityNotationParser,