}
    } else {
      tag 'LOCAL'
    }
  }
}

subprojects {
  project.getPlugins().withType(TestRerunPlugin) {
    tasks.withType(Test).configureEach(new Action<Test>() {
      @Override
      void execute(Test test) {
        test.doLast(new Action<Test>() {
          @Override
          void execute(Test t) {
            if(t.rerun.didRerun.get() == true) {

        tasks.register("updateContributorsInReleaseNotes", UpdateContributorsInReleaseNotes.class);
        tasks.withType(AbstractCheckOrUpdateContributorsInReleaseNotes.class).configureEach(task -> {
            task.getGithubToken().set(project.getProviders().environmentVariable("GITHUB_TOKEN"));
            task.getReleaseNotes().set(extension.getReleaseNotes().getMarkdownFile());

            dependencies {
               yamlRestTestImplementation "junit:junit:4.12"
            }

            // can't actually spin up test cluster from this test
           tasks.withType(Test).configureEach{ enabled = false }
        """

        String wrongApi = "wrong_version.json"
        String wrongTest = "wrong_version.yml"
        String additionalTest = "additional_test.yml"

sourceSets {
  integTest {
    compileClasspath += sourceSets["main"].output + configurations["testRuntimeClasspath"]
    runtimeClasspath += output + compileClasspath
  }
}

tasks.withType(JavaCompile).configureEach {
  options.encoding = 'UTF-8'
}

tasks.named('licenseHeaders').configure {
  // ignore gradle generated binary script plugins
  excludes << "Elasticsearch*Plugin.java"
}

            target: String?,
          ) = "${jvmMainSourceSet.getTaskName(verb, target)}ForFakeMain"
        }
      sourceSets.add(mainSourceSet)
      project.tasks.named { it.endsWith("ForFakeMain") }.configureEach { onlyIf { false } }

      return mainSourceSet
    }
  }

        // none of this stuff is applicable to the `:buildSrc` project tests
        File heapdumpDir = new File(project.getBuildDir(), "heapdump");

        project.getTasks().withType(Test.class).configureEach(test -> {
            File testOutputDir = new File(test.getReports().getJunitXml().getOutputLocation().getAsFile().get(), "output");

    }

    private void generateUserManual(Project project, TaskContainer tasks, ProjectLayout layout, GradleDocumentationExtension extension) {
        tasks.withType(AsciidoctorTask.class).configureEach(task -> {
            if (task.getName().equals("asciidoctor")) {
                // ignore this task
                task.setEnabled(false);
                return;
            }

        var projectVersion = providerFactory.provider(() -> project.getVersion());
        var generateMavenPoms = project.getTasks().withType(GenerateMavenPom.class);
        generateMavenPoms.configureEach(
            pomTask -> pomTask.setDestination(
                (Callable<String>) () -> String.format(
                    "%s/distributions/%s-%s.pom",

            "reason",
            "redundantKaptCheck",
            "redundantPluginAlert",
        ) -> true

        else -> false
    }

    gradle.lifecycle.beforeProject {
        tasks.configureEach {
            val task = this
            if (isIncompatible(task)) {
                task.notCompatibleWithConfigurationCache("Task is not compatible with the configuration cache")
            }
        }
    }

    }
    val testFilesCleanupService = testFilesCleanupServiceProvider.get()
    testFilesCleanupService.addProjectState(project.path, project.layout.buildDirectory.asFile, testFilesCleanup.reportOnly)

    project.tasks.configureEach {
        if (this is Test) {
            testFilesCleanupService.addTestBinaryResultsDir(path, binaryResultsDirectory.asFile)
            testFilesCleanupService.addTaskReports(path, traceJson())
        }