@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"
    }

import spock.lang.Specification

class UnmanagedImplStructStrategyTest extends Specification {
    def store = new DefaultModelSchemaStore(DefaultModelSchemaExtractor.withDefaultStrategies())

    def "assembles schema for unmanaged type"() {
        expect:
        def schema = store.getSchema(ModelType.of(SomeType))
        schema instanceof UnmanagedImplStructSchema
        !(schema instanceof ManagedImplSchema)

        """
        library.writeToProject(testDirectory)

        when:
        succeeds('assemble')

        then:
        result.assertTasksExecuted(':compileDebugSharedSwift', ':linkDebugShared', ':assemble')
        sharedLibrary('build/lib/main/debug/shared/Foo').assertExists()
    }

    def "can assemble static library followed by shared library"() {
        def library = new SwiftLib()
        makeSingleProject()

  compileDebugCpp -> linkDebug -> assembleDebug -> assemble -> build [dir=back]
  check -> build [dir=back]
  compileReleaseCpp -> linkRelease -> 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}
  empty1[shape=plain, label=""]

    }

    def addLifecycleTasks(BuildTestFile build) {
        build.buildFile << """
            tasks.maybeCreate("assemble")
            tasks.assemble.dependsOn gradle.includedBuilds*.task(':assemble')
        """
    }

    def applyPlugin(BuildTestFile build, boolean pluginsBlock = false, boolean withVersion = true) {
        if (pluginsBlock && withVersion) {

            hashCodeFor(
                containerElements = listOf(
                    entry<TaskContainer, DefaultTask>("assemble")
                )
            ),
            equalTo(
                hashCodeFor(
                    containerElements = listOf(
                        entry<TaskContainer, DefaultTask>("assemble")
                    )
                )
            )
        )

        assertThat(

        }
        another(NativeLibrarySpec) {
            binaries.all { buildable = false }
        }
    }
}
"""
        when:
        fails "assemble"

        then:
        failureDescriptionContains("Execution failed for task ':assemble'.")
        failure.assertHasCause("""No buildable binaries found:
  - shared library 'another:sharedLibrary': Disabled by user

	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:

        buildFile << """
            plugins {
                id 'war'
            }
        """

        file("src/main/webapp/index.jsp") << "<p>hi</p>"

        when:
        succeeds "assemble"

        then:
        file("build/libs/test.war").exists();
    }

    def "can customize archive names using convention properties"() {
        given:

                return allToLink + [install]
            }

            List<String> getAllToAssemble() {
                return allToLink + [assemble]
            }

            List<String> getAllToAssembleWithInstall() {
                return allToInstall + [assemble]
            }
        }

        class DebugTasks extends VariantTasks {
            @Override
            protected String getBuildType() {