}

    TestFile getCacheDir() {
        Preconditions.checkNotNull(cacheDir)
    }

    List<TestFile> listCacheFiles() {
        cacheDir.listFiles().findAll { it.name ==~ /\p{XDigit}{${Hashing.defaultFunction().hexDigits}}/ }.sort()
    }

    void deleteCacheFiles() {
        listCacheFiles().each { it.delete() }
    }

    @Override

                containsText("mainClass"),
                containsText("${expectedPackagePrefix}app.App")
            ))
        )

        def listFiles = [buildFile,
                         "src/main/${language}/${expectedPackageDirPrefix}list/LinkedList.${ext}",
                         "src/test/${language}/${expectedPackageDirPrefix}list/LinkedListTest.${ext}",

            }
            return new IncrementalNativeCompiler<T>(taskOutputs, compiler, deleter, compileStateCache, incrementalCompilation);
        }

        @Override
        public Set<File> getFiles() {
            List<File> includeRoots = ImmutableList.copyOf(includeDirs);
            compileStateCache = compilationStateCacheFactory.create(taskPath);

            && containsAll(getSystemProperties(), options.getSystemProperties())
            && containsAll(getEnvironment(), options.getEnvironment())
            && getBootstrapClasspath().getFiles().containsAll(options.getBootstrapClasspath().getFiles());
    }

    @Override
    public void checkDebugConfiguration(Iterable<?> arguments) {
        options.checkDebugConfiguration(arguments);
    }

    @Override

                final Set<RequestData> requestDataSet = new HashSet<>();
                if (includeContent) {
                    try {
                        final FTPFile[] files = client.listFiles(ftpInfo.getParent(), FTPFileFilters.NON_NULL);
                        validateRequest(client);
                        for (final FTPFile f : files) {

                }
            }
            return false;
        }

        @Override
        public void initialize(FileLock fileLock) {
            try {
                File[] files = getBaseDir().listFiles();
                if (files == null) {
                    throw new IOException("Cannot list files in " + getBaseDir());
                }
                for (File file : files) {

        } else if (expression == "configurations.compile.resolvedConfiguration.getFiles { true }") {

    kotlinCoreProjectEnvironment: KotlinCoreProjectEnvironment,
    compilerConfig: CompilerConfiguration,
    ktFiles: List<KtFile>,
): KtStaticProjectStructureProvider = buildProjectStructureProvider(kotlinCoreProjectEnvironment) {
    val (scriptFiles, _) = ktFiles.partition { it.isScript() }
    val platform = JvmPlatforms.defaultJvmPlatform

    fun KtModuleBuilder.addModuleDependencies(moduleName: String) {

        this.displayName = displayName;
    }

    @Override
    public String getDisplayName() {
        return displayName;
    }

    @Override
    public Set<File> getFiles() {
        return ImmutableSet.of();
    }

    @Override
    protected void visitContents(FileCollectionStructureVisitor visitor) {
    }

    @Override
    public FileTreeInternal getAsFileTree() {

        buildOperationRunner.run(new RunnableBuildOperation() {
            @Override
            public void run(BuildOperationContext context) {
                File[] oldXmlFiles = testResultsDir.listFiles(new FilenameFilter() {
                    @Override
                    public boolean accept(File dir, String name) {
                        return name.startsWith("TEST") && name.endsWith(".xml");
                    }