class NativeDependentComponentsReportIntegrationTest extends AbstractIntegrationSpec {

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

    def "displays dependents report for all components of the task's project"() {
        given:
        buildScript simpleCppBuild()

        when:
        run "dependentComponents"

        then:

        run "app:${language.compileTaskName}", "-x", "impl:${language.compileTaskName}"

        then:
        impl.noneRecompiled()
        app.recompiledClasses("C")
    }

    def "deletion of jar without dependents does not recompile any classes"() {
        source api: ["class A {}"], impl: ["class SomeImpl {}"]
        impl.snapshot { run language.compileTaskName }

        when:
        clearImplProjectDependencies()

import org.gradle.platform.base.internal.PlatformResolvers;
import org.gradle.platform.base.internal.dependents.BaseDependentBinariesResolutionStrategy;
import org.gradle.platform.base.internal.dependents.DefaultDependentBinariesResolver;
import org.gradle.platform.base.internal.dependents.DependentBinariesResolver;
import org.gradle.platform.base.plugins.BinaryBasePlugin;

import java.io.File;
import java.util.ArrayList;

        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(

			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"},
		},
		{

        return project;
    }

    private Dependency toDependency(MavenProject mavenProject) {
        Dependency dependency = new Dependency();
        dependency.setGroupId(mavenProject.getGroupId());
        dependency.setArtifactId(mavenProject.getArtifactId());
        dependency.setVersion(mavenProject.getVersion());
        return dependency;
    }

    resources.from(fileTree(resolveTemplate("native-dependents-resources")))
    resources.from(resolveTemplate("init.gradle"))
    daemonMemory = '3G'
}

performanceTest.registerTestProject("nativeDependentsDeep", NativeProjectWithDepsGeneratorTask) {
    resources.from(fileTree(resolveTemplate("native-dependents-resources")))
    resources.from(resolveTemplate("init.gradle"))

                    .getConstantToDependentsMapping()
                    .orElseThrow(() -> new GradleException("Constants to dependents mapping not present, but it should be"));
                Map<String, Set<String>> newSourceClassesMapping = jdkJavaResult.getSourceClassesMapping();
                Map<String, Set<String>> mergedSourceClassesMapping;

        then:
        impl.recompiledClasses 'B'
    }

    // We don't know if constant changed or some method signature changed,
    // so we have to check also private first level dependents
    def "recompile first-level private dependents on constant change"() {
        source api: ["class A { static final int X = 1; int method() { return 1; } }"],

abstract class CrossTaskIncrementalJavaCompilationIntegrationTest extends AbstractCrossTaskIncrementalCompilationIntegrationTest {
    CompiledLanguage language = CompiledLanguage.JAVA

    def "compilation fails for private dependents on incompatible change"() {
        source api: ["class A { int method() { return 1; } }"],
            impl: ["class X { private int foo() { return new A().method(); }}", "class Y { private int foo() { return new A().method(); }}"]