def events = buildOperations.progress(ProjectsIdentifiedProgressDetails)
        events.size() == 1
        events[0].details.buildPath == ":"
    }

    def "composite participants expose their project structure"() {
        createDirs("a", "nested", "nested/b")
        settingsFile << """
        include "a"
        includeBuild "nested"

        rootProject.name = "root"

import org.gradle.internal.component.ResolutionFailureHandler;

import javax.annotation.Nullable;
import java.util.Collection;
import java.util.List;

/**
 * A dependency that can participate in dependency resolution.
 * Note that various subtypes provide additional details, but these are not required by the core resolution engine.
 *

        then:
        failure.assertHasCause("Could not resolve org:transitive:1.+: Resolution strategy disallows usage of dynamic versions")
    }

    def "passes if a transitive dynamic selector doesn't participate in selection"() {
        buildFile << """
            dependencies {
                conf 'org:test:1.0'
                conf 'org:testB:1.0'
                conf 'org:testC:1.0'
            }

	z.rebalMu.Unlock()

	z.rebalMu.RLock()
	participants := make([]bool, len(z.rebalMeta.PoolStats))
	for i, ps := range z.rebalMeta.PoolStats {
		// skip pools which have completed rebalancing
		if ps.Info.Status != rebalStarted {
			continue
		}

		participants[i] = ps.Participating
	}
	z.rebalMu.RUnlock()

	for poolIdx, doRebalance := range participants {
		if !doRebalance {
			continue
		}

 * the proxy. This proxy connection is called a "TLS Tunnel" and is specified by
 * [RFC 2817][1]. The HTTP CONNECT request that creates this tunnel connection is special: it
 * does not participate in any [interceptors][Interceptor] or [event listeners][EventListener]. It
 * doesn't include the motivating request's HTTP headers or even its full URL; only the target
 * server's hostname is sent to the proxy.
 *

                module('org:a:1.0')
                module('org:b:1.0')
            }
        }
    }

    @Issue("gradle/gradle#12011")
    def "can detect capability conflict even when participants belong to a virtual platform (#first, #second)"() {
        given:
        repository {
            'aligned:foo:1.0'()
            'indirect:bar:1.0' {
                dependsOn 'other:baz:1.0'
            }

For example, if you add a dependency to your project, it becomes a _transitive dependency_ of your consumers, and therefore may participate in conflict resolution if the consumer needs a different version.

A lot of the problems Gradle handles are about fixing the mismatch between the expectations of a consumer and a producer.

* Each property getter or the corresponding field must be annotated with a property annotation like `@InputFile` and `@OutputDirectory`.
Properties that don't participate in up-to-date checks should be annotated with `@Internal`.

Any failed validations will result in a warning message.

For each plugin you are developing, add an entry to the `gradlePlugin {}` script block:

            }
        }
    }

    void "transitive dependencies of an dependency constraint do not participate in conflict resolution if it is not included elsewhere"() {
        given:
        mavenRepo.module("org", "foo", '1.0').dependsOn('org', 'bar', '1.1').publish()
        mavenRepo.module("org", "bar", '1.0').publish()

- For in-depth information about how to use Istio, visit [istio.io](https://istio.io)
- To ask questions and get assistance from our community, visit [Github Discussions](https://github.com/istio/istio/discussions)
- To learn how to participate in our overall community, visit [our community page](https://istio.io/about/community)

In this README:

- [Introduction](#introduction)
- [Repositories](#repositories)
- [Issue management](#issue-management)