test.setClasspath(test.getClasspath().plus(extraFipsJars))
        }
      }

      pluginManager.withPlugin("elasticsearch.testclusters") {
        afterEvaluate {
          // This afterEvaluate hooks is required to avoid deprecated configuration resolution
          // This configuration can be removed once system modules are available

        when:
        buildFile.text = """
            plugins {
             id 'elasticsearch.java'
            }

            compileJava.targetCompatibility = "1.10"
            afterEvaluate {
                assert compileJava.options.release.get() == 10
            }
        """
        then:
        gradleRunner("help").build()
    }

            to.attribute(minified, true).attribute(artifactType, "jar")
            parameters {
                keepClassesByCoordinates = keepPatterns
            }
        }
    }
    afterEvaluate {
        // Without afterEvaluate, configurations.all runs before the configurations' roles are set.
        // This is yet another reason we need configuration factory methods.

    }

    @Input
    public String getBox() {
        return box.get();
    }

    public void setBox(String box) {
        // TODO: should verify this against the Vagrantfile, but would need to do so in afterEvaluate once vagrantfile is unmodifiable
        this.box.set(box);
    }

    @Input
    public Map<String, Object> getHostEnv() {
        return hostEnv.get();
    }

    public LicenseHeadersTask() {
        setDescription("Checks sources for missing, incorrect, or unacceptable license headers");
    }

    /**
     * The list of java files to check. protected so the afterEvaluate closure in the
     * constructor can write to it.
     */
    @InputFiles
    @SkipWhenEmpty
    @PathSensitive(PathSensitivity.RELATIVE)
    public List<FileCollection> getJavaFiles() {

project.tasks.withType<AnimalSniffer> {
  if (targetName == "animalsnifferJvmMain") {
    animalsnifferSignatures = jvmSignature
  } else {
    animalsnifferSignatures = androidSignature
  }
}

afterEvaluate {
  tasks.withType<Test> {
    if (javaLauncher
        .get()
        .metadata.languageVersion
        .asInt() < 9
    ) {
      // Work around robolectric requirements and limitations

            .set("addQaCheckDependencies", new Closure<Object>(InternalPluginBuildPlugin.this, InternalPluginBuildPlugin.this) {
                public void doCall(Object it) {
                    project.afterEvaluate(project1 -> {
                        // let check depend on check tasks of qa sub-projects
                        final var checkTaskProvider = project1.getTasks().named("check");

        var publishingExtension = project.getExtensions().getByType(PublishingExtension.class);
        var publication = publishingExtension.getPublications().create("elastic", MavenPublication.class);
        project.afterEvaluate(project1 -> {
            if (project1.getPlugins().hasPlugin(ShadowPlugin.class)) {
                configureWithShadowPlugin(project1, publication);
            } else if (project1.getPlugins().hasPlugin(JavaPlugin.class)) {

        ext.set("licenseFile", null);
        ext.set("noticeFile", null);
        // add license/notice files
        project.afterEvaluate(p -> p.getTasks().withType(Jar.class).configureEach(jar -> {
            if (ext.has("licenseFile") == false
                || ext.get("licenseFile") == null
                || ext.has("noticeFile") == false

            tasks.named("composeDown").configure(t -> t.doLast(t2 -> getFileSystemOperations().delete(d -> d.delete(testfixturesDir))));
        } else {
            project.afterEvaluate(spec -> {
                if (extension.fixtures.isEmpty()) {
                    // if only one fixture is used, that's this one, but without a compose file that's not a valid configuration