/**
     * Visits the files of this set. Does not include any files that could not be selected. Failures to select or resolve artifacts are supplied to the visitor.
     */
    default void visitFiles(ResolvedFileVisitor visitor, boolean continueOnSelectionFailure) {
        visitArtifacts(new ArtifactVisitorToResolvedFileVisitorAdapter(visitor), continueOnSelectionFailure);
    }

    @Override
    protected void visitContents(FileCollectionStructureVisitor visitor) {
        ResolvedFileCollectionVisitor collectingVisitor = new ResolvedFileCollectionVisitor(visitor);
        getSelectedArtifacts().visitFiles(collectingVisitor, lenient);
        maybeThrowResolutionFailures(collectingVisitor);
    }

    /**
     * If the file collection is not lenient, rethrow any failures that occurred during the visit.
     *

                }
            }
            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)
            }
        }
    }

        1 * visitor.visitFile({ it.file == tempDir.file("dir1/file1") })
        1 * visitor.visitFile({ it.file == tempDir.file("dir1/file2") })
        1 * visitor.visitFile({ it.file == tempDir.file("dir1/file3") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir2") })
        1 * visitor.visitFile({ it.file == tempDir.file("dir2/file1") })
        1 * visitor.visitFile({ it.file == tempDir.file("dir2/file2") })

        1 * detector.startDetection(processor)
        then:
        1 * files.visit(_) >> { args ->
            FileVisitor visitor = args[0]
            assert visitor
            visitor.visitFile(class1)
            visitor.visitFile(class2)
        }
        then:
        1 * detector.processTestClass({ it.file.is(class1.file) && it.relativePath.is(class1.relativePath) })
        then:

            @Override
            public void visitFile(FileVisitDetails fileDetails) {
                files.add(fileDetails.getFile());
            }
        });
        return files;
    }

    @Override
    public boolean isEmpty() {
        final MutableBoolean found = new MutableBoolean();
        visit(new EmptyFileVisitor() {
            @Override
            public void visitFile(FileVisitDetails fileDetails) {

        return visitor.prepareForVisit(source);
    }

    public void visitFile(File file) {
        visitor.visitFile(file);
    }

    @Override
    public void visitArtifact(DisplayName variantName, AttributeContainer variantAttributes, ImmutableCapabilities capabilities, ResolvableArtifact artifact) {
        visitor.visitFile(artifact.getFile());
    }

    @Override

    }

    static void assertCanStopVisiting(FileTree tree) {
        boolean found = false
        FileVisitor visitor = [
                visitFile: {FileVisitDetails details ->
                    assertFalse(found)
                    found = true
                    details.stopVisiting()
                },
                visitDir: {FileVisitDetails details ->

        FileVisitDetails dirDetails = Mock()
        DefaultFileCopyDetails defaultFileCopyDetails = new DefaultFileCopyDetails(dirDetails, specResolver, objectFactory, fileSystem)

        when:
        copyFileVisitorImpl.visitFile(dirDetails)

        then:
        1 * instantiator.newInstance(DefaultFileCopyDetails.class, dirDetails, specResolver, objectFactory, fileSystem) >> defaultFileCopyDetails
        1 * specResolver.getAllCopyActions() >> []