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

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

        updateDocumentationExtension(project, documentationExtension);
        configurePlugin(project, documentationExtension);
    }

    private static void applyPlugin(Project project) {
        project.getPlugins().apply(DokkatooHtmlPlugin.class);
    }

    private static void updateDocumentationExtension(Project project, GradleDocumentationExtension extension) {

        final WarPluginConvention pluginConvention = objectFactory.newInstance(org.gradle.api.plugins.internal.DefaultWarPluginConvention.class, project);
        DeprecationLogger.whileDisabled(() -> project.getConvention().getPlugins().put("war", pluginConvention));
        return pluginConvention;
    }

    /**
     * This method is intended for internal use and should not be called.
     *

        }

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

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

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

        @Override

                    }
                });
            }
        });
    }

    @SuppressWarnings("rawtypes")
    protected void withBasePlugin(Action<Plugin> action) {
        project.getPlugins().withType(getBasePlugin(), action);
    }

    protected JavaPluginExtension getJavaPluginExtension() {
        return project.getExtensions().getByType(JavaPluginExtension.class);
    }

    @Inject

			"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)
			}

 * @throws [IllegalStateException] when there is no such object contained in this convention, or when there are multiple such objects
 * @see [Convention.getPlugin]
 */
@Deprecated("The concept of conventions is deprecated. Use extensions instead.")
inline fun <reified T : Any> Convention.getPlugin(): T =
    getPlugin(T::class)


/**
 * Locates the plugin convention object with the given type.
 *
 * @param conventionType the convention plugin type

        convention.extensionsAsDynamicObject.methUnknown()
    }

    @Test void testCanLocateConventionObjectByType() {
        assertSame(convention1, convention.getPlugin(TestPluginConvention1))
        assertSame(convention2, convention.getPlugin(TestPluginConvention2))
        assertSame(convention1, convention.findPlugin(TestPluginConvention1))
        assertSame(convention2, convention.findPlugin(TestPluginConvention2))
    }

    }

    @Override
    public Plugin getPlugin(String id) {
        Plugin<?> plugin = findPlugin(id);
        if (plugin == null) {
            throw new UnknownPluginException("Plugin with id " + id + " has not been used.");
        }
        return plugin;
    }

    @Override
    public Plugin getAt(String id) throws UnknownPluginException {
        return getPlugin(id);
    }

    @Override