}
            operations << "applying"
            apply plugin: '$appliedBy'
            operations << "applied"

            assert plugins["$detectedBy"]
            assert plugins.getPlugin("$detectedBy")
            assert pluginManager.hasPlugin("$detectedBy")
            assert pluginManager.findPlugin("$detectedBy").id == "$detectedBy"

            task verify {
                doLast {

; public abstract void release(); public abstract void removeAttribute(String); public abstract void setAttribute(String, Object); public static LogFactory getFactory() throws LogConfigurationExce; public static Log getLog(Class) throws LogConfigurationExce; public static Log getLog(String) throws LogConfigurationExce; public static void release(ClassLoader); public static void releaseAll(); protected static ClassLoader getContextClassLoade() throws LogConfigurationExce; private static LogFactory...

                PluginModel plugin = config.getPlugin(path);
                writePlugin(path, plugin, true);
            }
            for (String alias : aliases) {
                String childName = leafNodeForAlias(alias);
                if (!classNode.hasChild(childName)) {
                    PluginModel plugin = config.getPlugin(alias);
                    writePlugin(alias, plugin, false);

                            .map(ModelProblem::getException)
                            .filter(pluginArtifactNotFoundException)
                            .map(exc -> ((PluginResolutionException) exc.getCause()).getPlugin())
                            .anyMatch(isPluginPartOfRequestScope);
                })
                .orElse(false);
    }

    }

    @Override
    public <T> Provider<T> provider(Callable<T> value) {
        return providerFactory.provider(value);
    }

    @Override
    public LoggingManager getLogging() {
        return loggingManager;
    }

    @Override
    public Logger getLogger() {
        return LOGGER;
    }

    @Override
    public String toString() {
        return "script";

                    .collect(Collectors.joining(", "));
            PluginIncompatibleException pie = new PluginIncompatibleException(
                    pluginDescriptor.getPlugin(),
                    "The plugin " + pluginDescriptor.getId() + " has unmet prerequisites: " + messages,
                    prerequisiteExceptions.get(0));

        final String defaulModelId = DefaultLifecyclePluginAnalyzer.DEFAULTLIFECYCLEBINDINGS_MODELID;

        List<String> unversionedPlugins = executionPlan.getMojoExecutions().stream()
                .map(MojoExecution::getPlugin)
                .filter(p -> p.getLocation("version") != null
                        && p.getLocation("version").getSource() != null
                        && defaulModelId.equals(

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

        InputSource defaultBindings = new InputSource();
        defaultBindings.setModelId(DefaultLifecyclePluginAnalyzer.DEFAULTLIFECYCLEBINDINGS_MODELID);

        final Plugin plugin = mojoDescriptor.getPluginDescriptor().getPlugin();
        plugin.setLocation("version", new InputLocation(12, 34, defaultBindings));
        MojoExecution result = new MojoExecution(plugin, goal, executionId);

            convention.plugins["my"] = objects.newInstance<MyConvention>()
            tasks.register("noop")
        """)
        withBuildScript("""
            plugins { id("my-plugin") }

            convention.getPlugin(MyConvention::class).some("api.get")
            the<MyConvention>().some("kotlin.reified.get")
            the(MyConvention::class).some("kotlin.kclass.get")
            configure<MyConvention> { some("kotlin.configure") }