if (!visited.add(dep.getSelected())) {
            return
        }
        String reason = dep.selected.selectionReason.conflictResolution? "(C)" : "";
        sb.append(indent + dep + reason + " [" + dep.selected.dependents*.from.id.module.join(",") + "]\n");
        for (DependencyResult d : dep.getSelected().getDependencies()) {
            printNode(d, sb, visited, "  " + indent);
        }
    }

[[sec:build_dashboard_project_layout]]
== Project layout

The Build Dashboard plugin does not require any particular project layout.

[[sec:build_dashboard_dependency_management]]
== Dependency management

The Build Dashboard plugin does not define any dependency configurations.

[[sec:build_dashboard_configuration]]
== Configuration

        ConstantDependentsConsumer consumer = new ConstantDependentsConsumer(
            (String constantOrigin, String dependent) -> accessibleDependentToConstants.computeIfAbsent(dependent, { new LinkedHashSet<>() }).add(constantOrigin),
            (String constantOrigin, String dependent) -> privateDependentToConstants.computeIfAbsent(dependent, { new LinkedHashSet<>() }).add(constantOrigin)
        )
        compiler = new TestCompiler(

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.reporting.dependents.internal;

import org.gradle.api.Project;
import org.gradle.api.artifacts.component.LibraryBinaryIdentifier;
import org.gradle.model.ModelMap;
import org.gradle.model.internal.registry.ModelRegistry;

                    }
                }
            }
        '''.stripIndent()

        helloWorldApp.writeSources(file("src/main"), file("src/hello"), file("src/greetings"))
    }

    def "creates #taskPrefix dependents tasks"() {
        when:
        succeeds 'tasks'

        then:
        outputContains "${taskPrefix}DependentsGreetings"
        outputContains "${taskPrefix}DependentsGreetingsSharedLibrary"

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

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

import com.google.common.collect.LinkedListMultimap;
import org.gradle.api.artifacts.component.LibraryBinaryIdentifier;
import org.gradle.internal.Cast;
import org.gradle.platform.base.internal.BinarySpecInternal;

        buildFile << """
            task artifacts {
                def result = configurations.compile.incoming.resolutionResult.rootComponent
                doLast {
                    println result.get().dependents
                }
            }
        """

        when:
        module.pom.expectGet()
        module2.pom.expectGet()

        then:
        succeeds("artifacts")
    }

            String path = nameSerializer.read(decoder);
            resourceBuilder.add(new GeneratedResource(location, path));
        }
        return DependentsSet.dependents(privateBuilder.build(), accessibleBuilder.build(), resourceBuilder.build());
    }

    @Override
    public void write(Encoder encoder, DependentsSet dependentsSet) throws Exception {

			expectWarning: false,
			deleteOptions: &metav1.DeleteOptions{},
			requestInfo:   &genericapirequest.RequestInfo{APIGroup: "batch", APIVersion: ""},
		},
		{
			description:   "deletion: orphan dependents, no warnings",
			expectWarning: false,
			deleteOptions: &metav1.DeleteOptions{OrphanDependents: &orphanDependents},
			requestInfo:   &genericapirequest.RequestInfo{APIGroup: "batch", APIVersion: "v1"},
		},
		{

            .collect(Collectors.toSet());
        if (!classesWithJavaSource.isEmpty()) {
            // We need to collect just accessible dependents, since it seems
            // private references to classes are not problematic when Groovy compiler loads a class
            sourceFileChangeProcessor.processOnlyAccessibleChangeOfClasses(classesWithJavaSource, recompilationSpec);