var reaperServiceProvider = GradleUtils.getBuildService(project.getGradle().getSharedServices(), ReaperPlugin.REAPER_SERVICE_NAME);
        var extension = project.getExtensions().create("vagrant", VagrantExtension.class, project);
        var service = project.getExtensions().create("vagrantService", VagrantMachine.class, extension, reaperServiceProvider);

        project.getGradle()
            .getTaskGraph()
            .whenReady(

        configurePomGeneration(project);
        configurePublications(project);
    }

    private void configurePublications(Project project) {
        var publishingExtension = project.getExtensions().getByType(PublishingExtension.class);
        var publication = publishingExtension.getPublications().create("elastic", MavenPublication.class);
        project.afterEvaluate(project1 -> {

     * @return An Optional that contains the Java test SourceSet if it exists.
     */
    public static Optional<SourceSet> getJavaTestSourceSet(Project project) {
        return project.getExtensions().findByName("java") == null
            ? Optional.empty()
            : Optional.ofNullable(getJavaSourceSets(project).findByName(SourceSet.TEST_SOURCE_SET_NAME));
    }

    /**

                        "Elastic License 2.0", projectLicenseURL.get())
                )
        );
        // Default to the SSPL+Elastic dual license
        project.getExtensions().getExtraProperties().set("licenseCommit", licenseCommitProvider);
        project.getExtensions().getExtraProperties().set("projectLicenses", convention);
    }

    private boolean isSnapshotVersion(Project project) {

    }

    public void registerTestArtifactFromSourceSet(SourceSet sourceSet) {
        String name = sourceSet.getName();
        JavaPluginExtension javaPluginExtension = project.getExtensions().getByType(JavaPluginExtension.class);
        javaPluginExtension.registerFeature(name + "Artifacts", featureSpec -> {
            featureSpec.usingSourceSet(sourceSet);

    public VagrantShellTask() {
        extension = getProject().getExtensions().findByType(VagrantExtension.class);
        if (extension == null) {
            throw new IllegalStateException("elasticsearch.vagrant-base must be applied to create " + getClass().getName());
        }
        service = getProject().getExtensions().getByType(VagrantMachine.class);
    }

    @Input

 */
public class TestWithDependenciesPlugin implements Plugin<Project> {
    @Override
    public void apply(final Project project) {
        ExtraPropertiesExtension extraProperties = project.getExtensions().getExtraProperties();
        if (extraProperties.has("isEclipse") && Boolean.valueOf(extraProperties.get("isEclipse").toString())) {
            /* The changes this plugin makes both break and aren't needed by

        project.getExtensions().add("pluginsDir", pluginsDir);
        project.getTasks().register("createPluginsDir", EmptyDirTask.class, t -> {
            t.setDir(pluginsDir);
            t.setDirMode(0755);
        });

        File jvmOptionsDir = new File(project.getBuildDir(), "jvm-options-hack/jvm.options.d");
        project.getExtensions().add("jvmOptionsDir", jvmOptionsDir);

        var extension = project.getExtensions().getByType(PluginPropertiesExtension.class);

        // We've ported this from multiple build scripts where we see this pattern into
        // an extension method as a first step of consolidation.
        // We might want to port this into a general pattern later on.
        project.getExtensions()
            .getExtraProperties()

            .getAllprojects()
            .stream()
            .filter(p -> p.equals(this.project) == false)
            .filter(p -> p.getExtensions().findByType(TestFixtureExtension.class) != null)
            .map(project -> project.getExtensions().getByType(TestFixtureExtension.class))
            .flatMap(ext -> ext.serviceToProjectUseMap.entrySet().stream())
            .filter(entry -> entry.getKey().equals(serviceName))