def "applies JavaPlugin and adds convention object with default values"() {
        when:
        plugin.apply(project)

        then:
        project.plugins.hasPlugin(JavaPlugin.class)

        project.convention.getPlugin(ApplicationPluginConvention.class) != null
        project.applicationName == project.name
        project.mainClassName == null

    private final ScalaPlugin scalaPlugin = TestUtil.newInstance(ScalaPlugin)

    def appliesTheJavaPluginToTheProject() {
        when:
        scalaPlugin.apply(project)

        then:
        project.getPlugins().hasPlugin(JavaPlugin)
    }

    def addsScalaConventionToEachSourceSetAndAppliesMappings() {
        when:
        scalaPlugin.apply(project)

        then:
        def sourceSet = project.sourceSets.main

                }
            });

            task.from((Callable<FileCollection>) () -> {
                if (project.getPlugins().hasPlugin(JavaPlugin.class)) {
                    return null;
                } else {
                    return task.getAppDirectory().getAsFileTree();
                }
            });

        public void applyTo(PluginManagerInternal pluginManager) {
            PluginCoordinates altCoords = pluginRequest.getAlternativeCoordinates().orElse(null);
            if (altCoords != null && pluginManager.hasPlugin(altCoords.getId().getId())) {
                return;
            }

            pluginManager.apply(pluginRequest.getId().getId());
        }
    }

        }

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