"tooling-native",
          "unit-test-fixtures",
          "war"
        ],
        "parallelizationMethod": {
          "name": "TestDistribution"
        }
      },
      {
        "subprojects": [
          "build-cache-http",
          "ear",
          "instrumentation-reporting",
          "plugins-distribution",
          "plugins-jvm-test-fixtures",
          "plugins-jvm-test-suite",

#### Using test fixtures

Sometimes we want to share test fixtures to setup the code under test across multiple projects. There are basically two ways doing so.

Ideally we would use the build-in [java-test-fixtures](https://docs.gradle.org/current/userguide/java_testing.html#sec:java_test_fixtures) gradle plugin.
This plugin relies on having a separate sourceSet for the test fixtures code.

import org.gradle.api.tasks.SourceSet;
import org.gradle.api.tasks.SourceSetContainer;

/**
 * Ideally, this plugin is intended to be temporary and in the long run we want to move
 * forward to port our test fixtures to use the gradle test fixtures plugin.
 * */
public class InternalTestArtifactPlugin implements Plugin<Project> {

    @Override
    public void apply(Project project) {

    public void setPriority(int priority) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String getDescription() {
        return "Reports incorrect usages of integration test fixtures";
    }

    @Override
    protected Class<?> getAstVisitorClass() {
        return IntegrationTestFixtureVisitor.class;
    }

        "If it is needed as a transitive depenency, try adding it to the runtime classpath")
    }
  }
}

subprojects {
  if (project.path.startsWith(':test:fixtures:') || project.path.equals(':build-tools')) {
    // fixtures are allowed to use whatever dependencies they want...
    return
  }
  pluginManager.withPlugin('java') {
    checkDeps(configurations.compileClasspath)
    checkDeps(configurations.testCompileClasspath)
  }

            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
                    throw new IllegalStateException(
                        "No " + DOCKER_COMPOSE_YML + " found for " + project.getPath() + " nor does it use other fixtures."
                    );
                }
            });

        }
        if (fixtureProject.file(TestFixturesPlugin.DOCKER_COMPOSE_YML).exists() == false) {
            throw new IllegalArgumentException(
                "Project " + path + " is not a valid test fixture: missing " + TestFixturesPlugin.DOCKER_COMPOSE_YML
            );
        }
        fixtures.add(fixtureProject);
        // Check for exclusive access

    }

    override fun setName(name: String?) {
        throw UnsupportedOperationException()
    }

    override fun getDescription(): String = "Reports incorrect usages of integration test fixtures"

    override fun getAstVisitorClass(): Class<*> = IntegrationTestFixtureVisitor::class.java
}


class IntegrationTestFixtureVisitor : AbstractAstVisitor() {

    /**

 * Side Public License, v 1.
 */

import org.gradle.plugins.ide.eclipse.model.SourceFolder

plugins {
    id 'java-gradle-plugin'
    id 'java-test-fixtures'
    id 'eclipse'
}

group = "org.elasticsearch"

def minRuntimeJava = JavaVersion.toVersion(file('../build-tools-internal/src/main/resources/minimumRuntimeVersion').text)
targetCompatibility = minRuntimeJava

    "crossVersionTests": false
  },
  {
    "name": "project-features",
    "path": "platforms/core-configuration/project-features",
    "unitTests": false,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "project-features-api",
    "path": "platforms/core-configuration/project-features-api",
    "unitTests": false,
    "functionalTests": false,