}

        @Override
        public boolean isOffline() {
            return !includeLibraries();
        }

        private boolean includeLibraries() {
            return !project.getPlugins().hasPlugin(JavaPlugin.class);
        }

        @Override
        public boolean downloadSources() {
            return false;
        }

        @Override
        public boolean downloadJavaDoc() {

internal
fun Project.discoverBuildScript(): File? =
    buildFile.takeIf { it.isKotlinDslFile }


internal
fun Project.discoverPrecompiledScriptPluginScripts() =
    if (plugins.hasPlugin("org.gradle.kotlin.kotlin-dsl"))
        serviceOf<PrecompiledScriptPluginsSupport>()
            .collectScriptPluginFilesOf(this)
    else
        emptyList()


internal

    }

    def "can apply plugin by id"() {
        given:
        def project = TestUtil.createRootProject(null)
        project.apply plugin: 'native-component-model'

        expect:
        project.plugins.hasPlugin(NativeComponentModelPlugin)
    }

    public <T> T realizeModelElement(String path, Class<T> type) {
        realizeModelElement(path, ModelType.of(type))
    }

  </module>
</application>
"""

    def "applies base plugin and adds convention"() {
        when:
        project.pluginManager.apply(EarPlugin)

        then:
        project.getPlugins().hasPlugin(BasePlugin)
        project.convention.plugins.ear instanceof EarPluginConvention
    }

    def "creates configurations"() {
        when:
        project.pluginManager.apply(EarPlugin)

        and:

        this.softwareComponentFactory = softwareComponentFactory;
    }

    @Override
    public void apply(Project project) {
        if (project.getPluginManager().hasPlugin("java")) {
            // This already throws when creating `apiElements` so be eager to have a clear error message
            throw new IllegalStateException(

        for (ProjectInternal project : orderedProjects) {
            if (project.getPlugins().hasPlugin(ComponentModelBasePlugin.class)) {
                ModelRegistry modelRegistry = projectModelResolver.resolveProjectModel(project.getPath());

        project.file("config/checkstyle").mkdirs()
        project.file("custom").mkdirs()
    }

    def "applies reporting-base plugin"() {
        expect:
        project.plugins.hasPlugin(ReportingBasePlugin)
    }

    def "configures checkstyle configuration"() {
        def config = project.configurations.findByName("checkstyle")

        expect:
        config != null
        !config.visible

        plugins.each { project.pluginManager.apply(it) }

        when:
        modelBuilder.buildAll("org.gradle.tooling.model.eclipse.EclipseProject", project)

        then:
        project.plugins.hasPlugin(EclipseWtpPlugin) == hasWtpPlugin

        where:
        hasWtpPlugin | plugins
        false        | []
        false        | [JavaPlugin]
        true         | [WarPlugin]

        if (!pluginWithIds.isEmpty()) {
            return pluginWithIds.iterator().next().asAppliedPlugin();
        }
        return null;
    }

    @Override
    public boolean hasPlugin(String id) {
        return findPlugin(id) != null;
    }

    @Override
    public void withPlugin(final String id, final Action<? super AppliedPlugin> action) {

class PmdPluginTest extends AbstractProjectBuilderSpec {

    def setup() {
        project.pluginManager.apply(PmdPlugin)
    }

    def "applies reporting-base plugin"() {
        expect:
        project.plugins.hasPlugin(ReportingBasePlugin)
    }

    def "pmd 7.0.0 is loading the right dependencies"() {
        expect: