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

    def "available under jvm-toolchains id"() {
        expect:
        project.pluginManager.hasPlugin("jvm-toolchains")
    }

    def "registers javaToolchains extension"() {
        expect:
        project.extensions.getByType(JavaToolchainService) == project.extensions.getByName("javaToolchains")
    }

    }

    def "can reapply core plugin applied via plugins block"() {
        when:
        buildScript """
            plugins {
                id "java"
            }

            assert plugins.hasPlugin("java")

            apply plugin: "java"
        """

        then:
        succeeds "help"
    }

    def "can reapply core plugin applied via qualified id in plugins block"() {
        when:

    private final Set<File> libConfigFiles;

    public WtpClasspathAttributeSupport(Project project, EclipseModel model) {
        isUtilityProject = !project.getPlugins().hasPlugin(WarPlugin.class) && !project.getPlugins().hasPlugin(EarPlugin.class);
        EclipseWtp eclipseWtp = model.getWtp();
        EclipseWtpComponent wtpComponent = eclipseWtp.getComponent();
        libDirName = wtpComponent.getLibDeployPath();

        VisualCppToolChain.DEFAULT_NAME
    }

    def "can apply plugin by id"() {
        given:
        project.apply plugin: 'microsoft-visual-cpp-compiler'

        expect:
        project.plugins.hasPlugin(pluginClass)
    }

    def "makes a VisualCpp tool chain available"() {
        when:
        register()

        then:
        toolchain instanceof VisualCppToolChain
    }

            assert pluginManager.hasPlugin('$fixture.id')
        """

        and:
        runBuildWithScanRequest()

        then:
        pluginAppliedOnce()
    }

    def "does not apply plugin to nested builds in a composite"() {
        when:
        settingsFile << """
            includeBuild 'a'
            assert pluginManager.hasPlugin('$fixture.id')
        """

    @Issue('https://github.com/gradle/gradle/issues/15664')
    def 'plugins are applied in the order they are declared in the plugins block'() {
        given:
        publishPlugin """
            if (!project.pluginManager.hasPlugin('java')) {
                throw new Exception('plugin application order is not correct')
            }
        """

        when:
        buildScript """
            plugins {
                id 'java'

    private static final Predicate<Project> HAS_IDEA_AND_JAVA_PLUGINS = new Predicate<Project>() {
        @Override
        public boolean apply(Project project) {
            return project.getPlugins().hasPlugin(IdeaPlugin.class) && project.getPlugins().hasPlugin(JavaBasePlugin.class);
        }
    };
    public static final Function<Project, JavaVersion> SOURCE_COMPATIBILITY = new Function<Project, JavaVersion>() {
        @Override

    def "can apply plugin by id"() {
        when:
        dsl {
            apply plugin: 'component-base'
        }

        then:
        project.pluginManager.pluginContainer.hasPlugin(ComponentBasePlugin)
    }

    def "applies lifecycle base plugin only"() {
        when:
        dsl {
            apply plugin: ComponentBasePlugin
        }

        then:

    String getToolchainName() {
        "clang"
    }

    def "can apply plugin by id"() {
        given:
        project.apply plugin: 'clang-compiler'

        expect:
        project.plugins.hasPlugin(pluginClass)
    }

    def "makes a Clang tool chain available"() {
        when:
        register()

        then:
        toolchain instanceof ClangToolChain

    @Override
    String getToolchainName() {
        "gcc"
    }

    def "can apply plugin by id"() {
        given:
        project.apply plugin: 'gcc-compiler'

        expect:
        project.plugins.hasPlugin(pluginClass)
    }

    def "makes a Gcc tool chain available"() {
        when:
        register()

        then:
        toolchain instanceof GccToolChain