}
}

packageCycles {
    excludePatterns.add("org/gradle/nativeplatform/plugins/**")
    excludePatterns.add("org/gradle/nativeplatform/tasks/**")
    excludePatterns.add("org/gradle/nativeplatform/internal/resolve/**")
    excludePatterns.add("org/gradle/nativeplatform/toolchain/internal/**")
}

        callableDeclaration: KtCallableDeclaration,
        testServices: TestServices,
    ) {
        analyseForTest(callableDeclaration) {
            val typesToCheckOn = buildList {
                add(builtinTypes.int)
                add(buildClassType(StandardClassIds.List) { argument(builtinTypes.long) })
            }

            val symbol = callableDeclaration.getSymbol() as KaCallableSymbol
            val typeParameters = buildList {

            if (value.startsWith(">=")) {
                final GradleVersion minVersion = getVersion(value, 2);
                validateLowestTestedVersion(constraint, value, minVersion);
                specs.add(new Spec<GradleVersion>() {
                    @Override
                    public boolean isSatisfiedBy(GradleVersion element) {
                        return element.getBaseVersion().compareTo(minVersion) >= 0;

                includedFile.text = "input"

                includedFiles.add(includedFile)
                includedFilesCopies.add(spec.file("build/output/${it.includedFileName()}"))

                excludedFiles.add(spec.file("input/${it.excludedFileName()}"))
                excludedFilesCopies.add(spec.file("build/output/${it.excludedFileName()}"))
            }
        }

                collect(project, result)
            }
        }
        return result
    }

    private
    fun collect(project: ProjectState, projects: MutableSet<ProjectState>) {
        if (!projects.add(project)) {
            return
        }
        val parent = project.parent
        if (parent != null) {
            collect(parent, projects)
        }
    }

    private

        buildList {
            fe10Annotations.forEachIndexed { index, annotationDescriptor ->
                if (annotationDescriptor.classIdForAnnotation !in ignoredAnnotations) {
                    add(annotationDescriptor.toKaAnnotation(analysisContext, index))
                }
            }
        }
    }

    override val token: KaLifetimeToken
        get() = analysisContext.token

    }

    integTestDistributionRuntimeOnly(project(":distributions-publishing"))
}

strictCompile {
    ignoreRawTypes() // raw types used in public API
}

packageCycles {
    excludePatterns.add("org/gradle/plugins/signing/**")
}

tasks {
    integTest {
        usesJavadocCodeSnippets = true
    }

        for (BasicGradleProject project : buildModel.getProjects()) {
            SomeToolingModel model = controller.findModel(project, SomeToolingModel.class);
            if (model != null) {
                result.add(model.getMessage());
            }
        }
        return result;
    }

        because("BuildDashboard has specific support for JVM plugins (CodeNarc, JaCoCo)")
    }
}

strictCompile {
    ignoreRawTypes() // raw types used in public API
}

packageCycles {
    excludePatterns.add("org/gradle/api/reporting/internal/**")
}

val reportResources = tasks.register<Copy>("reportResources") {
    from(implementationResources)

    testFixturesImplementation(project(":internal-integ-testing"))
    testFixturesImplementation(project(":logging"))
}

packageCycles {
    excludePatterns.add("org/gradle/api/plugins/**")
}