when:
        module.dependencies << newDependency("a", "y", "1")
        then:
        thrown(UnsupportedOperationException)

        when:
        module.dependents <<   newDependency("a", "y2", "1")
        then:
        thrown(UnsupportedOperationException)
    }

    def "includes unresolved dependencies"() {
        given:
        def module = newModule()

        List<NativeBinarySpecInternal> dependents = state.getDependents(target);
        for (NativeBinarySpecInternal dependent : dependents) {
            List<DependentBinariesResolvedResult> children = doBuildResolvedResult(dependent, state, stack);
            result.add(new DefaultDependentBinariesResolvedResult(dependent.getId(), dependent.getProjectScopedName(), dependent.isBuildable(), isTestSuite(dependent), children));
        }

            .filter(constantOrigin -> !changedClasses.contains(constantOrigin))
            .forEach(constantOrigin -> {
                DependentsSet dependents = oldMapping.getConstantDependentsForClass(constantOrigin);
                Set<String> accessibleDependents = new HashSet<>(dependents.getAccessibleDependentClasses());
                accessibleDependents.removeIf(changedClasses::contains);

 * limitations under the License.
 */

package org.gradle.api.reporting.dependents

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class DependentComponentsReportIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        settingsFile << "rootProject.name = 'test'"
    }

    def "help displays dependents report task options"() {
        when:

// Note that a dependent with multiple ownerReferences for the target uid can end up in both lists.
func partitionDependents(dependents []*node, matchOwnerIdentity objectReference) (matching, nonmatching []*node) {
	ownerIsNamespaced := len(matchOwnerIdentity.Namespace) > 0
	for i := range dependents {
		dep := dependents[i]
		foundMatch := false
		foundMismatch := false

 * limitations under the License.
 */

package org.gradle.platform.base.internal.dependents;

import org.gradle.api.artifacts.component.LibraryBinaryIdentifier;

import java.util.List;

/**
 * A dependent binary and its dependents, node of a dependent binaries resolution result.
 */
public interface DependentBinariesResolvedResult {

    LibraryBinaryIdentifier getId();

        new ClassSetAnalysis(
            new ClassSetAnalysisData(Maps.transformValues(dependents) { hash }, dependents, classToConstants, fullRebuildCause),
            new AnnotationProcessingData([:], aggregatedTypes.getAllDependentClasses(), dependentsOnAll.getAllDependentClasses(), [:], dependentsOnAll.dependentResources, null),
            compilerApiData
        )
    }

        def a2 = first(c.dependencies).selected

        a2.is(a)

        first(b.dependents).is(first(a.dependencies))
        first(c.dependents).is(first(b.dependencies))
        first(a.dependents).is(first(c.dependencies))

        first(b.dependents).from.is(a)
        first(c.dependents).from.is(b)
        first(a.dependents).from.is(c)
    }

    def "accumulates and avoids duplicate dependencies"() {

}

type CacheToken uint64

type dependents interface {
	DependentConfigs() []ConfigHash
}

// typedXdsCache interface defines a store for caching XDS responses.
// All operations are thread safe.
type typedXdsCache[K comparable] interface {
	// Flush clears the evicted indexes.
	Flush()
	// Add adds the given key with the value and its dependents for the given pushContext to the cache.

    private void blackList(String id) {
        if (!blackList.contains(id)) {
            blackList.add(id);

            List<String> dependents = sorter.getDependents(id);

            if (dependents != null && !dependents.isEmpty()) {
                for (String dependentId : dependents) {
                    if (!buildSuccessesByProject.containsKey(dependentId)