then:
        1 * listener1.doSomething("param")
        1 * listener2.doSomething("param")
        1 * listener3.doSomething("param")
        0 * _
    }

    def "removes duplicates when adding listeners as a batch"() {
        def listener1 = Mock(TestListener)
        def listener2 = Mock(TestListener)
        def listener3 = Mock(TestListener)

    private Dependency doAdd(Configuration configuration, Object dependencyNotation, @Nullable Closure configureClosure) {
        if (dependencyNotation instanceof Configuration) {
            throw new GradleException("Adding a Configuration as a dependency is no longer allowed as of Gradle 8.0.");
        } else if (dependencyNotation instanceof ProviderConvertible<?>) {

        return referencedProjects;
    }

    /**
     * The referenced projects of this Eclipse project (*not*: java build path project references).
     * <p>
     * Referencing projects does not mean adding a build path dependencies between them!
     * If you need to configure a build path dependency use Gradle's dependencies section or
     * eclipse.classpath.whenMerged { classpath -&gt; ... to manipulate the classpath entries

        def tasksContainerCallbackBuildOps = findCallbackActionBuildOps('task container callback')
        tasksContainerCallbackBuildOps.size > 0 // not necessary to track exact count here; adding removing build-in tasks should not break this
        tasksContainerCallbackBuildOps.every { it.details.applicationId == callbackPluginApplication.details.applicationId }
    }

 * {@code asMap} has a few subtleties. As long as the set of keys remains unchanged, adding or
 * removing mappings does not affect the key iteration order. However, if you remove all values
 * associated with a key and then add the key back to the multimap, that key will come last in the
 * key iteration order.
 *
 * <p>The multimap does not store duplicate key-value pairs. Adding a new key-value pair equal to an
 * existing key-value pair has no effect.
 *

 * {@code asMap} has a few subtleties. As long as the set of keys remains unchanged, adding or
 * removing mappings does not affect the key iteration order. However, if you remove all values
 * associated with a key and then add the key back to the multimap, that key will come last in the
 * key iteration order.
 *
 * <p>The multimap does not store duplicate key-value pairs. Adding a new key-value pair equal to an
 * existing key-value pair has no effect.
 *

    # always skip the injection on pods that match that label selector, regardless of the global policy.
    # See https://istio.io/docs/setup/kubernetes/additional-setup/sidecar-injection/#more-control-adding-exceptions
    neverInjectSelector: []
    alwaysInjectSelector: []
    # injectedAnnotations are additional annotations that will be added to the pod spec after injection

            ManagedInstance target = (ManagedInstance) instance;
            modelNode.addReference(name, target.getManagedType(), target.getBackingNode(), descriptor);
        } else {
            modelNode.addLink(
                ModelRegistrations.unmanagedInstance(
                    ModelReference.of(modelNode.getPath().child(name), type),
                    Factories.constant(instance)
                )

                        }
                    }
                }
            }
        """

        expect:
        succeeds 'help'
    }


    def "pluginManagement block supports adding rule based plugin repository"() {
        given:
        settingsFile << """
            pluginManagement {
                resolutionStrategy.eachPlugin {
                    if(requested.id.name == 'noop') {

A web-based, searchable dependency report is available by adding the --scan option."""
    }

    def "shows selected versions in case of a multi-phase conflict"() {
        given:
        mavenRepo.module("foo", "foo", "1.0").publish()