def setup() {
        runner.minimumBaseVersion = "4.3"
        runner.args += ["-Dorg.gradle.caching.native=true"]
    }

    def "clean assemble with local cache (native project)"() {
        given:
        runner.tasksToRun = ["assemble"]

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

            include("b")
        """
        buildFile << """
            $block {
                plugins.apply('java-library')
            }
        """

        when:
        isolatedProjectsFails("assemble")

        then:
        fixture.assertStateStoredAndDiscarded {
            projectsConfigured(":", ":a", ":b")

        file("b/src/main/java/org/gradle/test/PersonImpl.java") << """
            package org.gradle.test;
            class PersonImpl implements Person { }
        """

        expect:
        succeeds "assemble"
    }

    def "war contains runtime classpath of upstream java project"() {
        given:
        createDirs("a", "b", "c", "d", "e")
        file("settings.gradle") << 'include "a", "b", "c", "d", "e"'

        given:
        withLibBuild()
        withAppBuild()

        when:
        inDirectory 'app'
        configurationCacheRun 'assemble'

        then:
        compositeBuildWorkGraphStoredAndLoaded()

        when:
        inDirectory 'app'
        configurationCacheRun 'assemble'

        then:
        compositeBuildWorkGraphLoaded()
    }

on 386 and amd64 because it has not shown an improvement on other platforms.
Hot block alignment can be disabled with `-gcflags=[<packages>=]-d=alignhot=0`

## Assembler {#assembler}

## Linker {#linker}

<!-- go.dev/issue/67401, CL 585556, CL 587220, and many more -->
The linker now disallows using a `//go:linkname` directive to refer to

        version current withTasks 'assemble' inDirectory(file("producer")) run()
        version previous withTasks 'tasks' requireDaemon() requireIsolatedDaemons() run()
    }

    def "task can use all methods declared by Task interface that AbstractTask specialises"() {
        given:
        prepareMethodUseTest(current.version)

        expect:
        version current withTasks 'assemble' inDirectory(file("producer")) run()

    @Scenario(type = PER_WEEK, operatingSystems = [LINUX], testProjects = ["largeJavaMultiProject", "largeMonolithicJavaProject"])
)
class ParallelBuildPerformanceTest extends AbstractCrossBuildPerformanceTest {

    def "clean assemble with 4 parallel workers"() {
        given:
        runner.testGroup = "parallel builds"
        runner.buildSpec {
            displayName("parallel")
            invocation {

	if !strings.Contains(string(out), "Unexpected alignment") {
		t.Errorf("Invalid alignment not detected for PCALIGN\n")
	}
}

// Verify register constants are correctly aligned. Much of the ppc64 assembler assumes masking out significant
// bits will produce a valid register number:
// REG_Rx & 31 == x
// REG_Fx & 31 == x
// REG_Vx & 31 == x
// REG_VSx & 63 == x
// REG_SPRx & 1023 == x
// REG_CRx & 7 == x

+ tasks
      | Type:   	org.gradle.model.ModelMap<org.gradle.api.Task>
      | Creator: 	Project.<init>.tasks()
    + assemble
          | Type:   	org.gradle.api.DefaultTask
          | Value:  	task ':assemble'
          | Creator: 	Project.<init>.tasks.assemble()
          | Rules:
             ⤷ copyToTaskContainer
    + build
          | Type:   	org.gradle.api.DefaultTask

            ImmutableSet.of(consumer, includedBuild)
        ]

        when:
        withWatchFs().run "assemble", "--info"
        then:
        executedAndNotSkipped(":includedBuild:jar")
        assertWatchableHierarchies(expectedWatchableHierarchies)

        when:
        withWatchFs().run("assemble", "--info")
        then:
        skipped(":includedBuild:jar")