import static org.hamcrest.MatcherAssert.assertThat

class Scala3PluginTest extends AbstractProjectBuilderSpec {

    def 'adds Scaladoc test to project for Scala 3'() {
        when:
        project.pluginManager.apply(ScalaPlugin)

        temporaryFolder.createFile('libs/scala3-library_3-3.0.1.jar)')
        project.dependencies.add('implementation', project.files('libs/scala3-library_3-3.0.1.jar)'))

        then:

import java.util.jar.Attributes

plugins {
    id("gradlebuild.module-identity")
}

val moduleIdentity = the<ModuleIdentityExtension>()

configureJarTasks()

pluginManager.withPlugin("java-base") {
    configureClasspathManifestGeneration()
}

fun configureJarTasks() {
    tasks.withType<Jar>().configureEach {
        archiveBaseName = moduleIdentity.baseName

	desiredStateOfWorld cache.DesiredStateOfWorld,
	volumePluginMgr *volume.VolumePluginMgr,
	pvcLister corelisters.PersistentVolumeClaimLister,
	pvLister corelisters.PersistentVolumeLister,
	csiMigratedPluginManager csimigration.PluginManager,
	intreeToCSITranslator csimigration.InTreeToCSITranslator) DesiredStateOfWorldPopulator {
	return &desiredStateOfWorldPopulator{
		loopSleepDuration:        loopSleepDuration,

    TaskNodeFactory factory
    def a = task('a')
    def b = task('b')
    def c = task('c')
    def d = task('d')
    def e = task('e')

    def setup() {
        project.gradle >> gradle
        project.pluginManager >> Stub(PluginManagerInternal)

        factory = new TaskNodeFactory(gradle, Stub(BuildTreeWorkGraphController), Stub(NodeValidator), new TestBuildOperationRunner(), Stub(ExecutionNodeAccessHierarchies))
    }

        anotherChildProject = TestUtil.createChildProject(project, "child2", new File("."))
    }

    def "location tracks change to outputFile property"() {
        when:
        project.pluginManager.apply(IdeaPlugin)
        def location = project.idea.project.location

        then:
        project.idea.project.outputFile == project.file("test-project.ipr")

    def instantiator = TestUtil.instantiatorFactory().inject()
    def pluginManager = new DefaultPluginManager(pluginRegistry, instantiator, target, new TestBuildOperationRunner(), new DefaultUserCodeApplicationContext(), CollectionCallbackActionDecorator.NOOP, TestUtil.domainObjectCollectionFactory())

    @Subject
    def container = pluginManager.pluginContainer

    @Rule

    private ProjectInternal project

    @Before
    void before() {
        project = TestUtil.create(temporaryFolder).rootProject()
        project.pluginManager.apply(GroovyBasePlugin)
    }

    @Test void appliesTheJavaBasePluginToTheProject() {
        assertTrue(project.getPlugins().hasPlugin(JavaBasePlugin));
    }

    @Test void appliesMappingsToNewSourceSet() {

import org.gradle.platform.base.PlatformBaseSpecification

class IvyPublishPluginTest extends PlatformBaseSpecification {
    PublishingExtension publishing

    def setup() {
        project.pluginManager.apply(IvyPublishPlugin)
        publishing = project.extensions.getByType(PublishingExtension)
    }

    def "no publication without component"() {
        expect:
        publishing.publications.empty
    }

class DefaultBasePluginConventionTest extends AbstractProjectBuilderSpec {

    private BasePluginConvention convention
    private BasePluginExtension extension

    def setup() {
        project.pluginManager.apply(BasePlugin)
        convention = project.convention.plugins.base
        extension =  project.extensions.base
    }

    def "default values"() {
        expect:

import static org.gradle.model.internal.type.ModelTypes.modelMap

class NativeComponentPluginTest extends AbstractProjectBuilderSpec {

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

    ModelMap<BinarySpec> realizeBinaries() {
        project.modelRegistry.find("binaries", modelMap(BinarySpec))
    }

    ModelMap<Task> realizeTasks() {