then:
        rule.subjectBinding.boundTo == node
        rule.bound
        bindings.getRulesWithSubject(nodeAtState("a", ModelNode.State.Mutated)) as List == [rule]
    }

    def "locates dependents of a node by-path"() {
        given:
        def node = node("a")
        def rule = rule("other") { it.inputReference("a", ModelNode.State.Created) }
        bindings.add(rule)
        addNode(node)

                .desc("If project list is specified, also build projects required by the list")
                .build());
        options.addOption(Option.builder(ALSO_MAKE_DEPENDENTS)
                .longOpt("also-make-dependents")
                .desc("If project list is specified, also build projects that depend on projects on the list")
                .build());
        options.addOption(Option.builder(LOG_FILE)

          | Creator: \tProject.<init>.tasks.dependencyInsight()
          | Rules:
             ⤷ copyToTaskContainer
    + dependentComponents
          | Type:   \torg.gradle.api.reporting.dependents.DependentComponentsReport
          | Value:  \ttask ':dependentComponents\'
          | Creator: \tProject.<init>.tasks.dependentComponents()
          | Rules:
             ⤷ copyToTaskContainer
    + help

import org.gradle.platform.base.TypeBuilder;
import org.gradle.platform.base.internal.HasIntermediateOutputsComponentSpec;
import org.gradle.platform.base.internal.PlatformResolvers;
import org.gradle.platform.base.internal.dependents.DependentBinariesResolver;

import javax.inject.Inject;
import java.io.File;

/**
 * A plugin that sets up the infrastructure for defining native binaries.
 */
@Incubating

    }

    /**
     * Can be overridden to indicate the relationship between this {@link Node} and a successor Node.
     *
     * @param dependency a non-successful successor node in the execution plan
     * @return Always returns false unless overridden.
     */
    protected boolean dependsOnOutcome(Node dependency) {
        return false;
    }

    /**

		s.informerFactory.Start(instanceContext.Done())

	} else {
		// Dynamic JSON informer fallback.
		// Cannot use shared dynamic informer since it would be impossible
		// to clean CRD informers properly with multiple dependents
		// (cannot start ahead of time, and cannot track dependencies via stopCh)
		informer = dynamicinformer.NewFilteredDynamicInformer(
			s.dynamicClient,
			mapping.Resource,
			corev1.NamespaceAll,

		c.Run(stop)
		for n := 0; n < b.N; n++ {
			key := makeCacheKey(n)
			req := &model.PushRequest{Start: zeroTime.Add(time.Duration(n))}
			c.Add(key, req, res)
		}
	})
	// to trigger clear index on old dependents
	b.Run("insert same key", func(b *testing.B) {
		c := model.NewXdsCache()
		stop := make(chan struct{})
		defer close(stop)
		c.Run(stop)
		// First occupy cache capacity

            </tr>
            <tr>
                <td>org.gradle.api.reporting.components.ComponentReport</td>
            </tr>
            <tr>
                <td>org.gradle.api.reporting.dependents.DependentComponentsReport</td>
            </tr>
            <tr>
                <td>org.gradle.api.reporting.model.ModelReport</td>
            </tr>
            <tr>

.Java plugin - _main_ source set dependency configurations
image::java-main-configurations.png[]

.Java plugin - _test_ source set dependency configurations
image::java-test-configurations.png[]

For each source set you add to the project, the Java plugins adds the following dependency configurations:

[[java_source_set_configurations]]
=== SourceSet dependency configurations

`__sourceSet__Implementation`::

                    ModelGoal dependency = newDependencies.get(i);
                    if (dependency.state == ModelGoal.State.Achieved) {
                        continue;
                    }
                    if (dependency.state == ModelGoal.State.NotSeen) {
                        queue.addFirst(dependency);
                        continue;
                    }