}
        }
        buildFile << """

class AssertingRule implements ComponentMetadataRule {

    void execute(ComponentMetadataContext context) {
        context.details.allVariants {
            withDependencies {
                it.each { dep ->
                    println "selectorSize:" + dep.artifactSelectors.size
                    println "classifier:" + dep.artifactSelectors[0]?.classifier

        publishTestPlugin("1.2", "from 1.2")
        useCustomRepository()

        buildFile << """
            buildscript {
                configurations.classpath {
                    withDependencies { dependencies ->
                       dependencies.configureEach { dep ->
                            dep.attributes {

                    this.attribute = attribute
                }

                void execute(ComponentMetadataContext context) {
                    context.details.allVariants {
                        withDependencies {
                            it.each {
                               it.attributes {
                                  it.attribute(attribute, '$attributeValue')
                               }

    private val groovyVersion: String
) : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withDependencies {
                val isAtLeastGroovy4 = VersionNumber.parse(groovyVersion).major >= 4
                val groovyGroup = if (isAtLeastGroovy4) "org.apache.groovy" else "org.codehaus.groovy"

}

// Remove gradleApi() and gradleTestKit() as we want to compile/run against Gradle modules
// TODO consider splitting `java-gradle-plugin` to provide only what's necessary here
configurations.all {
    withDependencies {
        remove(project.dependencies.gradleApi())
        remove(project.dependencies.gradleTestKit())
    }
}

publishing.publications.withType<MavenPublication>().configureEach {

        configurations["testCompileClasspath"].extendsFrom(platformImplementation)
        configurations["testRuntimeClasspath"].extendsFrom(platformImplementation)
        platformImplementation.withDependencies {
            // use 'withDependencies' to not attempt to find platform project during script compilation
            add(project.dependencies.create(platform(project(":distributions-dependencies"))))
        }
    }
}

                                        + "to the dependencyManagement section of the POM.");
                    }
                }
            }

            return target.withDependencyManagement(depMgmt.withDependencies(dependencies.values()));
        }
        return target;
    }

    private String toString(Dependency dependency) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder

        }
    }

    private void addPlatformDependencyToAllVariants(ModuleComponentIdentifier platformId) {
        allVariants(v -> v.withDependencies(dependencies -> {
            dependencies.add(Maps.of("group", platformId.getGroup(), "name", platformId.getModule(), "version", platformId.getVersion()),

    attributes.attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.EXTERNAL))
    isCanBeResolved = true
    isCanBeConsumed = false
    withDependencies {
        this.add(project.dependencies.create(project))
        this.add(project.dependencies.create(project.dependencies.platform(project(":distributions-dependencies"))))
    }
}

                                        + "to the dependencyManagement section of the POM."));
                    }
                }
            }

            return target.withDependencyManagement(depMgmt.withDependencies(dependencies.values()));
        }
        return target;
    }

    private String toString(Dependency dependency) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder