}

    private void configureSchema(ProjectInternal project) {
        AttributesSchemaInternal attributesSchema = (AttributesSchemaInternal) project.getDependencies().getAttributesSchema();
        JavaEcosystemSupport.configureSchema(attributesSchema, objectFactory);

    def setup() {
        AttributesSchema schema = new DefaultAttributesSchema(TestUtil.instantiatorFactory(), SnapshotTestUtil.isolatableFactory())
        JavaEcosystemSupport.configureSchema(schema, TestUtil.objectFactory())
        compatibilityRules = schema.compatibilityRules(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE)

import org.gradle.internal.component.resolution.failure.type.IncompatibleGraphVariantFailure;
import org.gradle.util.GradleVersion;

public class GradlePluginVariantsSupport {

    public static void configureSchema(AttributesSchemaInternal attributesSchema) {
        AttributeMatchingStrategy<GradlePluginApiVersion> strategy = attributesSchema.attribute(GradlePluginApiVersion.GRADLE_PLUGIN_API_VERSION_ATTRIBUTE);

        AttributesSchemaInternal attributesSchema = (AttributesSchemaInternal) Objects.requireNonNull(dependencyResolutionServices).getAttributesSchema();
        JavaEcosystemSupport.configureSchema(attributesSchema, dependencyResolutionServices.getObjectFactory());

        RepositoryHandler repositoryHandler = dependencyResolutionServices.getResolveRepositoryHandler();

        def schema = new DefaultAttributesSchema(TestUtil.instantiatorFactory(), SnapshotTestUtil.isolatableFactory())
        DependencyManagementTestUtil.platformSupport().configureSchema(schema)
        GradlePluginVariantsSupport.configureSchema(schema)
        schema
    }

    abstract boolean addAllDependenciesAsConstraints()

    def schema = new DefaultAttributesSchema(TestUtil.instantiatorFactory(), SnapshotTestUtil.isolatableFactory())
    def ep = Stub(AttributeMatchingExplanationBuilder)

    def setup() {
        GradlePluginVariantsSupport.configureSchema(schema)
    }

    def "Gradle #currentGradleVersion #acceptsOrRejects 7.0 api"() {
        given:
        def accepts = acceptsOrRejects == 'accepts'

        when:

        this.dependencyLockingHandler = dependencyResolutionServices.getDependencyLockingHandler();
        this.buildLogicBuilder = buildLogicBuilder;
        JavaEcosystemSupport.configureSchema(dependencyResolutionServices.getAttributesSchema(), dependencyResolutionServices.getObjectFactory());
    }

    @Override
    public void dependencies(Closure configureClosure) {

        return regularPlatform.equals(category) || enforcedPlatform.equals(category);
    }

    public Category getRegularPlatformCategory() {
        return regularPlatform;
    }

    public void configureSchema(AttributesSchemaInternal attributesSchema) {
        configureCategoryDisambiguationRule(attributesSchema);

        this.transforms = transforms;
        this.artifactTypeContainer = artifactTypeContainer;
        this.objects = objects;
        this.platformSupport = platformSupport;
        configureSchema();
        dynamicMethods = new DynamicAddDependencyMethods(configurationContainer, new DirectDependencyAdder());
    }

    @Override
    public Dependency add(String configurationName, Object dependencyNotation) {

    ]

    def setup() {
        // apply Java ecosystem rules
        buildFile << """
            org.gradle.api.internal.artifacts.JavaEcosystemSupport.configureSchema(
                dependencies.attributesSchema,
                project.objects
            )
        """
    }

    private static boolean leaksRuntime(testVariant, repoType, prevRepoType = null) {