public PreCreateOutputParentsStep(Step<? super C, ? extends R> delegate) {
        this.delegate = delegate;
    }

    @Override
    public R execute(UnitOfWork work, C context) {
        work.visitOutputs(context.getWorkspace(), new UnitOfWork.OutputVisitor() {
            @Override
            public void visitOutputProperty(String propertyName, TreeType type, UnitOfWork.OutputFileValueSupplier value) {

    public void writeToFile(File target, TransformExecutionResult result) {
        List<String> resultFileContents = new ArrayList<>(result.size());

        result.visitOutputs(new TransformExecutionResult.OutputVisitor() {
            @Override
            public void visitEntireInputArtifact() {
                resultFileContents.add(INPUT_FILE_PATH_PREFIX);
            }

    }

    @Override
    public TransformExecutionResult getRegisteredOutputs() {
        TransformExecutionResult result = resultBuilder.build();
        result.visitOutputs(new TransformExecutionResult.OutputVisitor() {
            @Override
            public void visitEntireInputArtifact() {
                validate(inputArtifact);
            }

            @Override

        return result;
    }

    private void cleanupStaleOutputs(UnitOfWork work, C context) {
        Set<File> filesToDelete = new HashSet<>();
        work.visitOutputs(context.getWorkspace(), new UnitOfWork.OutputVisitor() {
            @Override
            public void visitOutputProperty(String propertyName, TreeType type, UnitOfWork.OutputFileValueSupplier value) {

        String identity = hasher.hash().toString();
        return () -> identity;
    }

    @Override
    @OverridingMethodsMustInvokeSuper
    public void visitOutputs(File workspace, OutputVisitor visitor) {
        File instrumentedOutput = instrumentedOutput(workspace);

        creator(target)

        when:
        def result = step.execute(work, context)

        then:
        result == delegateResult

        _ * work.shouldCleanupStaleOutputs() >> true
        _ * work.visitOutputs(_) { UnitOfWork.OutputVisitor visitor ->
            visitor.visitOutputProperty("output", TreeType.FILE, UnitOfWork.OutputFileValueSupplier.fromStatic(target, TestFiles.fixed(target)))
        }

    override fun visitIdentityInputs(visitor: InputVisitor) {
        visitor.visitInputProperty(BUILD_SRC_CLASSLOADER_INPUT_PROPERTY) { classLoaderHash }
    }

    override fun visitOutputs(workspace: File, visitor: UnitOfWork.OutputVisitor) {
        val sourcesOutputDir = getSourcesOutputDir(workspace)
        val classesOutputDir = getClassesOutputDir(workspace)

                            () -> TestFiles.fixed(entry.value)
                        )
                    )
                }
            }

            @Override
            void visitOutputs(File workspace, UnitOfWork.OutputVisitor visitor) {
                outputs.forEach { name, spec ->

            visitor.visitInputProperty(CLASSPATH_PROPERTY_NAME, () -> classLoaderHierarchyHasher.getClassLoaderHash(classLoader));
        }

        @Override
        public void visitOutputs(File workspace, OutputVisitor visitor) {
            super.visitOutputs(workspace, visitor);
            File metadataDir = metadataDir(workspace);

        then:
        _ * work.allowedToLoadFromCache >> true
        1 * buildCacheController.load(cacheKey, _) >> Optional.of(loadMetadata)

        then:
        _ * work.visitOutputs(_ as File, _ as UnitOfWork.OutputVisitor) >> { File workspace, UnitOfWork.OutputVisitor visitor ->
            visitor.visitLocalState(localStateFile)
        }