def binary = Stub(DefaultCppBinary)
        binary.name >> name
        binary.names >> Names.of(name)
        binary.targetMachine >> Stub(CppPlatform)

        when:
        project.pluginManager.apply(CppBasePlugin)
        project.components.add(binary)

        then:
        def compileCpp = project.tasks[taskName]
        compileCpp instanceof CppCompile

    // Only used for testing
    public DefaultLifecycleExecutionPlanCalculator(
            BuildPluginManager pluginManager,
            DefaultLifecycles defaultLifecycles,
            MojoDescriptorCreator mojoDescriptorCreator,
            LifecyclePluginResolver lifecyclePluginResolver) {
        this.pluginManager = pluginManager;
        this.defaultLifecycles = defaultLifecycles;
        this.mojoDescriptorCreator = mojoDescriptorCreator;

    private final BuildPluginManager pluginManager;
    private final RepositorySystem repositorySystem;
    private final MetadataReader metadataReader;

    @Inject
    public DefaultPluginPrefixResolver(
            BuildPluginManager pluginManager, RepositorySystem repositorySystem, MetadataReader metadataReader) {
        this.pluginManager = pluginManager;
        this.repositorySystem = repositorySystem;

class JavaLibraryDistributionPluginTest extends AbstractProjectBuilderSpec {

    def "applies JavaLibraryPlugin and adds convention object with default values"() {
        when:
        project.pluginManager.apply(JavaLibraryDistributionPlugin)

        then:
        project.plugins.hasPlugin(JavaLibraryPlugin.class)
        project.extensions.getByType(DistributionContainer.class) != null

import static org.hamcrest.CoreMatchers.not
import static spock.util.matcher.HamcrestSupport.that

class CheckstylePluginTest extends AbstractProjectBuilderSpec {

    def setup() {
        project.pluginManager.apply(CheckstylePlugin)
        project.file("config/checkstyle").mkdirs()
        project.file("custom").mkdirs()
    }

    def "applies reporting-base plugin"() {
        expect:

        binary.targetMachine >> Stub(TargetMachine)
        binary.targetPlatform >> Stub(SwiftPlatform)
        binary.sourceCompatibility >> project.objects.property(SwiftVersion)

        when:
        project.pluginManager.apply(SwiftBasePlugin)
        project.components.add(binary)

        then:
        def compileSwift = project.tasks[taskName]
        compileSwift instanceof SwiftCompile

    def "apply adds java-library plugin"() {
        when:
        project.pluginManager.apply(JavaGradlePluginPlugin)

        then:
        project.plugins.findPlugin(JavaLibraryPlugin)
        project.plugins.findPlugin(JavaPlugin)
    }

    def "apply adds gradleApi dependency to api"() {
        when:
        project.pluginManager.apply(JavaGradlePluginPlugin)

        then:
        project.configurations

    abstract Class<? extends Task> getCompileTaskClass()

    abstract String getPluginName()

    def "creates source set with conventional locations for components"() {
        when:
        dsl {
            pluginManager.apply pluginClass

            model {
                components {
                    exe(NativeExecutableSpec)
                    lib(NativeLibrarySpec)
                }
            }
        }

        visitor.visitDependency(producingProject.getDependencies().create(producingProject));
    }

    @Override
    public void applyTo(PluginManagerInternal pluginManager) {
        pluginManager.apply(pluginId.getId());
    }

    static Optional<PluginResolution> resolvePlugin(GradleInternal gradle, PluginId requestedPluginId) {

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

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