project.getPluginManager().apply(VisualStudioExtensionRules.class);

        if (isRoot()) {
            project.getPluginManager().apply(VisualStudioPluginRootRules.class);
        }

        project.getPlugins().withType(ComponentModelBasePlugin.class).all(it -> project.getPluginManager().apply(VisualStudioPluginProjectRules.class));
    }

    private void includeBuildFileInProject(VisualStudioExtensionInternal extension) {

			"plugins":    plugins,
		}
	} else {
		// Assume it is a network list file
		newMap = existingMap
		plugins, err := util.GetPlugins(newMap)
		if err != nil {
			return nil, fmt.Errorf("existing CNI config: %v", err)
		}

		for i, rawPlugin := range plugins {
			plugin, err := util.GetPlugin(rawPlugin)
			if err != nil {
				return nil, fmt.Errorf("existing CNI plugin: %v", err)
			}

                        false);
            }

            Build build = project.getModel().getDelegate().getBuild();
            if (build != null) {
                for (Plugin plugin : build.getPlugins()) {
                    addEdge(
                            projectMap,
                            vertexMap,
                            project,
                            projectVertex,

        // However, the latter should go away in the future, while the application here is inherent to the builder
        rootProject.getPluginManager().apply(IdeaPlugin.class);
        IdeaModel ideaModelExt = rootProject.getPlugins().getPlugin(IdeaPlugin.class).getModel();
        IdeaProjectInternal ideaProjectExt = (IdeaProjectInternal) ideaModelExt.getProject();

        List<Project> allProjects = new ArrayList<>(rootProject.getAllprojects());

                checkNoDependencies(parent, visited);
            }
        }
    }

    private void configurePublishing(Project project) {
        project.getPlugins().withType(PublishingPlugin.class, plugin -> {
            PublishingExtension publishing = project.getExtensions().getByType(PublishingExtension.class);

        DeprecationLogger.whileDisabled(() ->
            new DslObject(sourceSet).getConvention().getPlugins().put("groovy", groovySourceSet)
        );
        return groovySourceSet.getGroovy();
    }

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

                @Override
                public void apply(Project project) {
                    JavaApplication dslModel = getApplication();

                    project.getPlugins().apply(ApplicationPlugin.class);

                    linkDslModelToPlugin(project, dslModel);
                }

                private void linkDslModelToPlugin(Project project, JavaApplication dslModel) {

                    plugin.setConfiguration(new Xpp3Dom(configuration));
                }
                extensionPlugins.add(plugin);
            }

            for (Plugin plugin : build.getPlugins()) {
                if (plugin.isExtensions()) {
                    extensionPlugins.add(plugin);
                }
            }
        }

        if (extensionPlugins.isEmpty()) {

            public class TestPluginTest {
                @Test
                public void test() {
                    Project project = ProjectBuilder.builder().build();
                    project.getPlugins().apply("test-plugin");
                }
            }
        """

        when:
        executer.withJdkWarningChecksEnabled()

        then:
        succeeds "test"
    }