* 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;

            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 {

[[sec:build_dashboard_tasks]]
== Tasks

The Build Dashboard plugin adds the following task to the project:

				continue
			}
			uidsToCheck = append(uidsToCheck, ownerRef.UID)
		}
		for dependent := range node.dependents {
			// if we've already inspected this UID, don't add it to be inspected again
			if _, ok := interestingNodes[dependent.identity.UID]; ok {
				continue
			}
			uidsToCheck = append(uidsToCheck, dependent.identity.UID)
		}
	}

	return toDOTNodesAndEdges(interestingNodes)
}

        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")
    }

 * 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 com.google.common.base.Predicate;
import com.google.common.collect.Sets;
import org.gradle.api.tasks.diagnostics.internal.graph.NodeRenderer;

			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);