file("test-api-changes.json"),
                            rootProject.layout.projectDirectory,
                            newUpgradedPropertiesFile.get().asFile,
                            oldUpgradedPropertiesFile.get().asFile,
                            object : Action<me.champeau.gradle.japicmp.report.RichReport> {

    return FilePredicate.IS_DIRECTORY;
  }

  /**
   * Returns a predicate that returns the result of {@link File#isFile} on input files.
   *
   * @since 15.0
   */
  public static Predicate<File> isFile() {
    return FilePredicate.IS_FILE;
  }

  private enum FilePredicate implements Predicate<File> {
    IS_DIRECTORY {
      @Override
      public boolean apply(File file) {

            }.filter {
                it.isFile
            }
        }
    }

    @get:InputFiles
    @get:PathSensitive(PathSensitivity.RELATIVE)
    abstract val packageInfoFiles: ConfigurableFileCollection

    @get:OutputFile
    abstract val outputFile: RegularFileProperty

    private val baseDir = project.layout.settingsDirectory.asFile

    @TaskAction
    fun action() {

    File asciiFile = getTestFile("ascii.txt");
    File dir = asciiFile.getParentFile();
    assertTrue(Files.isDirectory().apply(dir));
    assertFalse(Files.isFile().apply(dir));

    assertFalse(Files.isDirectory().apply(asciiFile));
    assertTrue(Files.isFile().apply(asciiFile));
  }

  /** Returns a root path for the file system. */
  private static File root() {
    return File.listRoots()[0];
  }

        reports.filter { it.isFile && it.toPath().startsWith(projectBuildDirPath) }
            .map { projectBuildDirPath.relativize(it.toPath()).toString() to it }
            .apply { zip(rootBuildDir.resolve("report$projectPathName.zip"), this) }

        reports.filter { it.isFile && !it.toPath().startsWith(projectBuildDirPath) }
            .forEach { report ->

      "$prefix/samples/guide/src/main/java/okhttp3/recipes/kt",
    ).map { File(it) }

  return directories.flatMap {
    it
      .listFiles()
      .orEmpty()
      .filter { f -> f.isFile }
      .toList()
  }
}

internal class MainTestProvider : SimpleProvider() {
  override fun arguments(): List<Any> {
    val mainFiles = mainFiles()
    return mainFiles
      .map {

        val temporaryBndFile = File.createTempFile("bnd", ".bnd", temporaryDir)
        IO.writer(temporaryBndFile).use { writer ->
          val bndFileVal = bndfile.asFile.getOrNull()
          if (bndFileVal != null && bndFileVal.isFile) {
            Processor(gradleProperties).let { p ->
              p.loadProperties(bndFileVal).store(writer, null)
            }
          } else {

        }
    }

    private
    fun assertLeftoverFilesCleanedUpEventually(vararg leftoverFiles: String) {
        leftoverFiles.forEach {
            assertTrue(projectDir.resolve(it).walk().filter { it.isFile }.toList().isEmpty())
        }
    }

    @Test
    fun `fail build if leftover file found and test passes`() {
        val result = run(":successful-test-with-leftover:test").buildAndFail()

            final File noImageFile = new File(outputFile.getAbsolutePath() + NOIMAGE_FILE_SUFFIX);
            final Path noImagePath = noImageFile.toPath();
            if (!noImageFile.isFile() || systemHelper.getCurrentTimeAsLong() - noImageFile.lastModified() > noImageExpired) {
                try {
                    Files.deleteIfExists(noImagePath);
                } catch (final IOException e) {

                        logger.warn("Failed to delete output file: {}", outputFile.getAbsolutePath(), e);
                    }
                    return false;
                }

                if (outputFile.isFile() && outputFile.length() == 0) {
                    logger.warn("Thumbnail file is empty: id={}", thumbnailId);
                    try {
                        if (Files.deleteIfExists(outputPath2)) {