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

    def appliesTheJavaPluginToTheProject() {
        expect:
        project.getPlugins().hasPlugin(JavaBasePlugin)
    }

    def addsZincConfigurationToTheProject() {
        when:
        def configuration = project.configurations.getByName(ScalaBasePlugin.ZINC_CONFIGURATION_NAME)

        then:

        delegate.toolchainManagement

    override fun sourceControl(configuration: Action<in SourceControl>) =
        delegate.sourceControl(configuration)

    override fun getPlugins(): PluginContainer =
        delegate.plugins

    override fun apply(closure: Closure<Any>) =
        delegate.apply(closure)

    override fun apply(action: Action<in ObjectConfigurationAction>) =

     *
     * @return the plugin container
     * @see #apply
     * @see PluginManager#hasPlugin(String)
     */
    PluginContainer getPlugins();

    /**
     * Applies zero or more plugins or scripts.
     * <p>
     * The given closure is used to configure an {@link ObjectConfigurationAction}, which “builds” the plugin application.
     * <p>

            private final Map<Class<?>, Optional<PluginId>> classToPlugin = new ConcurrentHashMap<>();

            private ProjectScopedTypeOriginInspector(Project project) {
                this.plugins = project.getPlugins();
                this.pluginManager = (PluginManagerInternal) project.getPluginManager();
            }

            @Override
            public Optional<PluginId> findPluginDefining(Class<?> type) {

         * not interested in any of the executions bound to it.
         */

        for (Plugin plugin : project.getBuild().getPlugins()) {
            for (PluginExecution execution : plugin.getExecutions()) {
                // if the phase is specified then I don't have to go fetch the plugin yet and pull it down

        return vcsUrl;
    }

    /**
     * Returns the declared plugins.
     *
     * @return the declared plugins, never null
     */
    public NamedDomainObjectContainer<PluginDeclaration> getPlugins() {
        return plugins;
    }

    /**
     * Configures the declared plugins.
     *
     * @param action the configuration action to invoke on the plugins
     */

        assertEquals("4.0.0", project4.getModelVersion());

        Build build = project4.getBuild();
        List<Plugin> plugins = build.getPlugins();

        Map<String, Integer> validPluginCounts = new HashMap<>();

        String testPluginArtifactId = "maven-compiler-plugin";

        // this is the plugin we're looking for.

    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

            if (build != null) {
                validate20RawPlugins(problems, build.getPlugins(), "build.plugins.plugin.", EMPTY, request);

                PluginManagement mgmt = build.getPluginManagement();
                if (mgmt != null) {
                    validate20RawPlugins(
                            problems, mgmt.getPlugins(), "build.pluginManagement.plugins.plugin.", EMPTY, request);
                }
            }

        return versions.values();
    }

    public Collection<LibraryEntry> getLibraries() {
        return libraries.values();
    }

    public Collection<PluginEntry> getPlugins() {
        return plugins.values();
    }

    public String registerLibrary(String module, String version) {
        String alias = fullyQualifiedAliases ? coordinatesToAlias(module) : moduleToAlias(module);