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

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

                    if (hasLeftover) {
                        doFirst {
                            project.layout.buildDirectory.file("tmp/teŝt files/leftover/leftover").get().asFile.apply {
                                parentFile.mkdirs()
                                createNewFile()
                            }
                        }
                    }

        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 {

        val currentVersion = versionFile.asFile.get().readText().trim()
        val patchVersion = bumpPatchVersion(currentVersion)
        val major = currentVersion.split(".")[0].toInt()

        val previousReleasedVersion = fetchVersionFromGradleServices(major, currentVersion)
        versionFile.asFile.get().writeText(patchVersion)
        updateReleasedVersionFile(releasedVersionsFile.asFile.get(), previousReleasedVersion)

    val rootPropertiesFile = layout.projectDirectory.file("../gradle.properties")
    doLast {
        val buildLogicProperties = readProperties(buildLogicPropertiesFile.asFile)
        val rootProperties = readProperties(rootPropertiesFile.asFile)
        val jvmArgs = listOf(buildLogicProperties, rootProperties).map { it.getProperty("org.gradle.jvmargs") }.toSet()
        if (jvmArgs.size > 1) {

        // fess.var.path and fess.conf.path not set

        final File varFile = new File(varDir.toFile(), "test.txt");
        varFile.getParentFile().mkdirs();
        varFile.createNewFile();

        // Should throw because only fess.webapp.path is set and the file is not under it
        assertThrows(IllegalArgumentException.class, () -> action.validateFilePath(varFile.getAbsolutePath()));
    }

fun Directory.parentOrRoot(): Directory = if (this.file("version.txt").asFile.exists()) {
    this
} else {
    val parent = dir("..")
    when {
        parent.file("version.txt").asFile.exists() -> parent
        this == parent -> error("Cannot find 'version.txt' file in root of repository")
        else -> parent.parentOrRoot()
    }
}

    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];
  }

        boolean hasWeb = false;
        boolean hasFile = false;
        for (final ProtocolType type : values) {
            if (type == ProtocolType.WEB) {
                hasWeb = true;
            } else if (type == ProtocolType.FILE) {
                hasFile = true;
            }
        }

        assertTrue("Should have WEB protocol type", hasWeb);