then: "the adapter rule is called once"
        noExceptionThrown()
        1 * adapterRule.execute(_) >> {
            def adapter = it[0]
            adapter.withDependencies(dependenciesRule)
            adapter.withDependencyConstraints(constraintsRule)
            adapter.attributes(attributesRule)
        }
        0 * _

        when:
        resolve(gradleMetadata)

    public void execute(ComponentMetadataContext context) {
            println "Rule executed on \${context.details.id}"
            context.details.allVariants {
                println("Variant \$it")
                withDependencies { deps ->
                    deps.each {
                       println "See dependency: \$it"
                    }
                }
            }
    }
}

dependencies {
    components {

    }

    def "copied configuration inherits withDependencies actions"() {
        def original = conf()
        def seenOriginal = [] as Set<DependencySet>
        original.withDependencies { seenOriginal.add(it) }

        def copied = original.copy()
        def seenCopied = [] as Set<DependencySet>
        copied.withDependencies { seenCopied.add(it) }

 *     id 'java'
 * }
 *
 * repositories {
 *     mavenCentral()
 * }
 *
 * dependencies {
 *     components {
 *         withModule("jaxen:jaxen") {
 *             allVariants {
 *                 withDependencies {
 *                     removeAll { it.group in ["dom4j", "jdom", "xerces", "maven-plugins", "xml-apis", "xom"] }
 *                 }
 *             }
 *
 *         }
 *     }

                    def details = context.details
                    if (details.id.name == 'indirect') {
                        details.allVariants {
                            withDependencies {
                                it.each {
                                    if (it.name == 'bom') {
                                        it.attributes {

                            .preserveModelVersion(false)
                            .root(false)
                            .parent(null)
                            .dependencyManagement(dependencyManagement.withDependencies(dependencies))
                            .build(null),
                    model);
            builder.packaging(POM_PACKAGING);
            builder.profiles(prune(model.getProfiles()));

                classpath = files()
            }
            dependencies {
                api "org.test:dep1:1.0"
            }
            configurations.api.withDependencies { deps ->
                deps.each { dep ->
                    dep.version { require 'X' }
                }
                deps.add project.dependencies.create("org.test:dep2:1.0")
            }

At times, a plugin may want to modify the dependencies of a configuration before it is resolved.
The `withDependencies` method permits dependencies to be added, removed or modified programmatically.

.Modifying dependencies on a configuration
====
include::sample[dir="snippets/dependencyManagement/customizingResolution-withDependencies/kotlin",files="build.gradle.kts[tags=configuration-with-dependencies]"]

	}
	return b
}

// WithDependencies sets the Dependencies field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Dependencies field is set to the value of the last call.

NOTE: This behavior is working reliable since Gradle 6.1. Effectively, it is similar to a <<component_metadata_rules.adoc#sec:component_metadata_rules,component metadata rule>> that adds a platform dependency to all members of the platform using `withDependencies`.

[[sec:virtual_platform]]
=== Align versions of modules without a published platform

.A dependency version alignment rule
====