given:
        project_a_depends_on_project_b()

        when:
        withBuildCache().run 'assemble'

        then:
        executedAndNotSkipped ':b:jar'
        executedAndNotSkipped ':a:jar'

        when:
        make_abi_compatible_change_on_b()

        withBuildCache().run 'clean', 'assemble'

        then:
        executedAndNotSkipped ':b:jar'
        skipped ':a:compileJava'
    }

	AND	$~1, R3
	LSL	$3, R3
	SUB	R3, RSP

	// R4: size of stack arguments (n-8)*8
	// R5: &args[8]
	// R6: loop counter, from 0 to (n-8)*8
	// R7: scratch
	// R8: copy of RSP - (R2)(RSP) assembles as (R2)(ZR)
	SUB	$8, R0, R4
	LSL	$3, R4
	ADD	$(8*8), R12, R5
	MOVD	$0, R6
	MOVD	RSP, R8
stackargs:
	MOVD	(R6)(R5), R7
	MOVD	R7, (R6)(R8)
	ADD	$8, R6
	CMP	R6, R4
	BNE	stackargs

_8args:

  rankdir=LR

  compileDebugCpp -> linkDebug -> assemble -> build [dir=back]
  linkDebug -> assembleDebug [dir=back]
  check -> build [dir=back]
  compileReleaseCpp -> linkRelease -> assembleRelease [dir=back]
  clean

  // Ensure ordering
  compileDebugCpp -> compileReleaseCpp -> clean [style=invis]
  {rank=same compileDebugCpp compileReleaseCpp clean}

  check -> assemble -> assembleDebug -> assembleRelease [style=invis]

  compileDebugCpp -> createDebug -> assembleDebug -> assemble -> build [dir=back]
  check -> build [dir=back]
  compileReleaseCpp -> createRelease -> assembleRelease [dir=back]
  clean

  // Ensure ordering
  compileDebugCpp -> compileReleaseCpp -> clean [style=invis]
  {rank=same compileDebugCpp compileReleaseCpp clean}

  assemble -> empty1 -> empty2 -> check [style=invis]
  {rank=same assemble check empty1 empty2}

    def "clean assemble with precompiled headers" () {
        given:
        runner.testGroup = 'pre-compiled header builds'
        runner.buildSpec {
            displayName("Using PCH")
            invocation {
                args("-PusePCH")
                tasksToRun("clean", "assemble")
            }
        }
        runner.baseline {

        app.library.writeSources(file("src/hello"))
        app.googleTestTests.writeSources(file("src/helloTest"))
    }

    @ToBeFixedForConfigurationCache
    def "buildDependentsHello assemble and check all hello binaries"() {
        given:
        useConventionalSourceLocations()
        useStandardConfig()

        when:
        succeeds 'buildDependentsHello'

        then:

executable: gradle
args: assemble
expected-output-file: assemble.out

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Tasks for assembling Assembler sources for a native runtime.
 */

)
class NativeParallelPerformanceTest extends AbstractCrossBuildPerformanceTest {

    def "clean assemble with parallel workers"() {
        given:
        runner.testGroup = 'parallel builds'
        runner.buildSpec {
            displayName("parallel")
            invocation {
                tasksToRun("clean", "assemble")
            }
        }
        runner.baseline {
            displayName("serial")

    @ToBeFixedForConfigurationCache
    def "assembler"() {
        given:
        sample assembler

        when:
        run "installMainExecutable"

        then:
        executedAndNotSkipped ":compileMainExecutableMainC", ":linkMainExecutable", ":mainExecutable"

        and:
        installation(assembler.dir.file("build/install/main")).exec().out == "5 + 7 = 12\n"
    }