}
            }
            ParallelResolveArtifactSet.wrap(CompositeResolvedArtifactSet.of(artifactSets), buildOperationExecutor).visit(visitor);
        }

        @Override
        public void visitFiles(ResolvedFileVisitor visitor, boolean continueOnSelectionFailure) {
            List<ResolvedArtifactSet> artifactSets = new ArrayList<>();
            for (Object element : elements) {

        }
    }

    private SelectedArtifactSet selectedArtifacts(Set<File> files = []) {
        Stub(SelectedArtifactSet) {
            visitFiles(_, _) >> { ResolvedFileVisitor visitor, boolean l ->
                files.each {
                    visitor.visitFile(it)
                }
                visitor.endVisitCollection(null)
            }
        }
    }

                private final int num = new Random().nextInt(100000)

                @Override
                void visitDir(FileVisitDetails dirDetails) {}

                @Override
                void visitFile(FileVisitDetails fileDetails) {
                    fileDetails.file.text = fileDetails.file.text.replace('original', Integer.toString(num))
                }
            }

            void verify() {

	}
	return gofmtBuf.String()
}

func report(err error) {
	scanner.PrintError(os.Stderr, err)
	exitCode = 2
}

func walkDir(path string) {
	filepath.WalkDir(path, visitFile)
}

func visitFile(path string, f fs.DirEntry, err error) error {
	if err == nil && isGoFile(f) {
		err = processFile(path, false)
	}
	if err != nil {
		report(err)
	}
	return nil
}

        }

        protected abstract FileVisitResult doPreVisitDirectory(Path dir, BasicFileAttributes attrs);

        @Override
        public final FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
            collector.recordVisitFile();
            return doVisitFile(file, attrs);
        }

                    } else {
                        super.visitCallExpression(expression)
                    }
                }
            }
            visitor.visitFile(ktFile)
        }
        if (errors.isNotEmpty()) {
            testServices.assertions.fail { errors.joinToString("\n") }
        }
        val actualText = actualTextBuilder.toString()

                    Files.exists(transformedDir.resolve("transformed/$MERGE_OUTPUT_DIR/${INSTRUMENTATION_CLASSPATH_MARKER.fileName}"))
            }

            @Override
            FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                Files.delete(file)
                return FileVisitResult.CONTINUE
            }

            @Override

                return if (Files.isReadable(dir))
                    FileVisitResult.CONTINUE
                else
                    FileVisitResult.SKIP_SUBTREE
            }

            override fun visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult {
                if (!Files.isRegularFile(file) || !Files.isReadable(file))
                    return FileVisitResult.CONTINUE

            @Override
            void visitDir(FileVisitDetails dirDetails) {
            }

            @Override
            void visitFile(FileVisitDetails fileDetails) {
                if (fileDetails.file.name == ".ready") {
                    markerFile = fileDetails.file
                }
            }
        })

        ImmutableList.Builder<CandidateClassFile> builder = ImmutableList.builder();
        task.getCandidateClassFiles().visit(new EmptyFileVisitor() {
            @Override
            public void visitFile(FileVisitDetails fileDetails) {
                builder.add(new DefaultCandidateClassFile(fileDetails.getFile(), fileDetails.getPath()));
            }
        });
        return builder.build();
    }