*/

package org.gradle.api.artifacts;

import org.gradle.api.Action;

/**
 * A rule that modify {@link ComponentMetadataDetails component metadata}.
 *
 * @since 4.9
 */
public interface ComponentMetadataRule extends Action<ComponentMetadataContext> {

import org.gradle.api.artifacts.ComponentMetadataRule
import org.gradle.api.artifacts.dsl.ComponentMetadataHandler

import org.junit.Test


class ComponentMetadataHandlerExtensionsTest {

    @Test
    fun all() {
        val componentMetadataHandler = mock<ComponentMetadataHandler> {
            on { all(any<Class<ComponentMetadataRule>>()) } doReturn mock<ComponentMetadataHandler>()
        }

        }
        buildFile << """

@CacheableRule
class CachedRuleA implements ComponentMetadataRule {
    public void execute(ComponentMetadataContext context) {
            println 'Rule A executed'
            context.details.changing = true
    }
}

@CacheableRule
class CachedRuleB implements ComponentMetadataRule {
    public void execute(ComponentMetadataContext context) {

plugins {
    `java-library`
}

repositories {
    mavenCentral()
}

// tag::config-component-metadata-rule[]
@CacheableRule
abstract class TargetJvmVersionRule @Inject constructor(val jvmVersion: Int) : ComponentMetadataRule {
    @get:Inject abstract val objects: ObjectFactory

    override fun execute(context: ComponentMetadataContext) {
        context.details.withVariant("compile") {
            attributes {

plugins {
    id 'java-library'
}

repositories {
    mavenCentral()
}

// tag::config-component-metadata-rule[]
@CacheableRule
abstract class TargetJvmVersionRule implements ComponentMetadataRule {
    final Integer jvmVersion
    @Inject TargetJvmVersionRule(Integer jvmVersion) {
        this.jvmVersion = jvmVersion
    }

    @Inject abstract ObjectFactory getObjects()

    void execute(ComponentMetadataContext context) {

import org.gradle.api.artifacts.ComponentMetadataRule
import org.gradle.api.artifacts.dsl.ComponentMetadataHandler


/**
 * Adds a class based rule that may modify the metadata of any resolved software component.
 *
 * @param T the rule to be added
 * @return this
 *
 * @see [ComponentMetadataHandler.all]
 */
inline fun <reified T : ComponentMetadataRule> ComponentMetadataHandler.all(): ComponentMetadataHandler =

            ext.rulesUninvoked = []

            class InvokedRule implements ComponentMetadataRule {
                static boolean ruleInvoked

                public void execute(ComponentMetadataContext context) {
                    ruleInvoked = true
                }
            }

            class NotInvokedRule implements ComponentMetadataRule {
                static boolean ruleInvoked

    private val moduleToKeep: Set<String>
) : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withDependencies {
                removeAll { !moduleToKeep.contains(it.name) }
            }
        }
    }
}


inline

        buildFile << """
repositories {
    flatDir {
        dirs 'lib'
    }
}

configurations {
    conf
}

class AssertingRule implements ComponentMetadataRule {
    RepositoryResourceAccessor accessor

    @javax.inject.Inject
    public AssertingRule(RepositoryResourceAccessor accessor) {
        this.accessor = accessor
    }

            }
        """
    }

    def "#thing can be added using #notation notation"() {
        when:
        buildFile << """
            class ModifyRule implements ComponentMetadataRule {
                void execute(ComponentMetadataContext context) {
                    context.details.withVariant("$variantToTest") {
                        with${toCamelCase(thing)} {