configs, minusConfigs, false, NullGradleApiSourcesResolver.INSTANCE, classpath.getTestConfigurations().getOrElse(Collections.emptySet())).visit(visitor);
        return visitor.getFiles();
    }

    public void enhance(Classpath classpath) {
        for (ClasspathEntry entry : classpath.getEntries()) {
            if (entry instanceof AbstractClasspathEntry) {

                def resolveMainClassName() {
                    // Find first root package class with a name that ends with `Main`
                    def rootPackageFiles = classpath.files.collectMany { it.isDirectory() ? it.listFiles().toList() : [] }
                    def mainClassFile = rootPackageFiles.find { it.name.endsWith 'Main.class' }
                    mainClassFile.name.with {
                        take(length() - '.class'.length())

}

func runPkgCover(t *testing.T, outdir string, tag string, incfg string, mode string, infiles []string, errExpected bool) ([]string, string, string) {
	// Write the pkgcfg file.
	outcfg := filepath.Join(outdir, "outcfg.txt")

	// Form up the arguments and run the tool.
	outfiles, outfilelist := writeOutFileList(t, infiles, outdir, tag)
	args := []string{"-pkgcfg", incfg, "-mode=" + mode, "-var=var" + tag, "-outfilelist", outfilelist}

        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    public static Collection<File> listFiles(File directory, String[] extensions, boolean recursive) {
        return FileUtils.listFiles(directory, extensions, recursive);
    }

    public static List<String> toPaths(Collection<File> files) {
        List<String> paths = new ArrayList<String>();

    /**
     * Returns the resolved dependency graph as a reference to the root component.
     */
    Provider<ResolvedComponentResult> getRootComponent();

    @Override
    FileCollectionInternal getFiles();

    @Override
    ArtifactCollectionInternal getArtifacts();

    /**
     * Returns the files attached to this configuration, if any. These should be represented as dependencies, but are currently represented as files as a migration step.
     */
    Set<LocalFileDependencyMetadata> getFiles();

    /**
     * Calculates the set of artifacts for this configuration.
     *
     * <p>Note that this may be expensive, and should be called only when required.</p>
     */

        return visitor.files;
    }

    @Override
    @Deprecated
    public Set<File> getFiles(Spec<? super Dependency> dependencySpec) {
        DeprecationLogger.deprecateMethod(LenientConfiguration.class, "getFiles(Spec)")
            .withAdvice("Use a lenient ArtifactView with a componentFilter instead.")
            .willBeRemovedInGradle9()

        if (shouldRemoveContentsOf(file, handling)) {
            File[] contents = file.listFiles();

            // Something else may have removed it
            if (contents == null) {
                return false;
            }

            boolean attemptedToDeleteAnything = false;

                asFileFilter(new NonReservedFileFilter(singleton(baseDir))));
            File[] result = baseDir.getParentFile().listFiles(combinedFilter);
            return result == null ? Collections.<File>emptySet() : Arrays.asList(result);
        });
        this.cacheNamePattern = cacheNamePattern;
        this.cacheVersionMapping = cacheVersionMapping;

            return;
        }

        if (element instanceof Task) {
            visitor.accept((FileCollectionInternal) ((Task) element).getOutputs().getFiles());
        } else if (element instanceof TaskOutputs) {
            visitor.accept((FileCollectionInternal) ((TaskOutputs) element).getFiles());
        } else if (DeferredUtil.isNestableDeferred(element)) {
            Object deferredResult = DeferredUtil.unpackNestableDeferred(element);