}
            cleanEclipse.doLast {
                assert !file(".classpath").exists()
                assert !file(".project").exists()
                assert !file('.settings').exists() || file('.settings').listFiles().length == 0
            }
        }
    }

		t.Skip("skipping in short mode")
	}

	testenv.MustHaveGoBuild(t)

	// Collect non-test files.
	dirFiles := make(map[string][]string)
	root := filepath.Join(testenv.GOROOT(t), "src")
	walkPkgDirs(root, func(dir string, filenames []string) {
		dirFiles[dir] = filenames
	}, t.Error)

	c := &stdlibChecker{
		dirFiles: dirFiles,
		pkgs:     make(map[string]*futurePackage),
	}

	start := time.Now()

        left.visitDependencies(context);
    }

    @Override
    protected Set<File> getIntrinsicFiles() {
        Set<File> files = new LinkedHashSet<File>(left.getFiles());
        files.removeAll(right.getFiles());
        return files;
    }

    @Override
    public boolean contains(File file) {
        return left.contains(file) && !right.contains(file);
    }

        for (int i = 0; i < artifactSets.length; i++) {
            fileCollections[i] = (FileCollectionInternal) artifactSets[i].getFiles();
        }
        files = new UnionFileCollection(taskDependencyFactory, fileCollections);
    }

    @Override
    public FileCollection getFiles() {
        return files;
    }

            for (NativeDependencySet nativeDependencySet : binary.getLibs()) {
                runtimeFiles.add(getFiles(nativeDependencySet));
            }
            return runtimeFiles;
        }

        protected abstract FileCollection getFiles(NativeDependencySet nativeDependencySet);
    }

        graph.getResolutionFailure().ifPresent(ex -> {
            throw ex;
        });
        return graph;
    }

    @Override
    public FileCollectionInternal getFiles() {
        return doGetArtifactView(Actions.doNothing()).getFiles();
    }

    @Override
    public ArtifactCollectionInternal getArtifacts() {
        return doGetArtifactView(Actions.doNothing()).getArtifacts();
    }

        return libDirAndSubdirs;
    }

    private static void collectWithSubdirectories(File root, Collection<File> collection) {
        collection.add(root);
        File[] subDirs = root.listFiles(DIRECTORY_FILTER);
        if (subDirs != null) {
            for (File subdirectory : subDirs) {
                collectWithSubdirectories(subdirectory, collection);
            }
        }
    }

/**
 * List files ordered by filename for reproducibility.
 * Never returns null.
 */
fun File.listFilesOrdered(filter: ((File) -> Boolean)? = null): List<File> =
    listFiles()
        ?.let { if (filter != null) it.filter(filter) else it.asList() }
        ?.sortedBy { it.name }

            </tr>
            <tr>
                <td>verbose</td>
                <td><literal>false</literal></td>
            </tr>
            <tr>
                <td>listFiles</td>
                <td><literal>false</literal></td>
            </tr>
            <tr>
                <td>configurationScript</td>
                <td><literal>null</literal></td>
            </tr>

     */
    @Console
    public boolean isListFiles() {
        return listFiles;
    }

    /**
     * Sets whether to log the files to be compiled. Defaults to {@code false}.
     */
    public void setListFiles(boolean listFiles) {
        this.listFiles = listFiles;
    }

    /**