'mediumCppMultiWithMacroIncludes',
                'bigCppMulti'
            ])
    ])
    def "clean assemble (native)"() {
        given:
        def iterations = runner.testProject in ['smallNative', 'smallCppApp', 'smallCppMulti'] ? 40 : null
        runner.tasksToRun = ["assemble"]
        runner.cleanTasks = ["clean"]
        runner.runs = iterations
        runner.warmUpRuns = iterations

        when:

    def "is enabled by default"() {
        buildFile << """
            apply plugin: "java"
        """

        when:
        run("assemble", "--info")
        then:
        outputContains(ENABLED_IF_AVAILABLE_MESSAGE)
        outputContains(ACTIVE_MESSAGE)
    }

    def "can be enabled via gradle.properties (enabled: #enabled)"() {

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

/**
 * Plugins for building from Assembler language sources.
 */
@org.gradle.api.Incubating

  rankdir=LR

  compileDebugSwift -> linkDebug -> assemble -> build [dir=back]
  linkDebug -> assembleDebug [dir=back]
  check -> build [dir=back]
  compileReleaseSwift -> linkRelease -> assembleRelease [dir=back]
  clean

  // Ensure ordering
  compileDebugSwift -> compileReleaseSwift -> clean [style=invis]
  {rank=same compileDebugSwift compileReleaseSwift clean}

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

        buildFile << """
            apply plugin: 'cpp-application'
        """

        expect:
        succeeds "assemble"
        result.assertTasksExecuted(tasks.debug.allToInstall, ':assemble')
        // TODO - should skip the task as NO-SOURCE
        result.assertTasksSkipped(tasks.debug.allToInstall, ':assemble')
    }

    @ToBeFixedForConfigurationCache
    def "build fails when compilation fails"() {
        given:

Depends on: `link__Variant__`
::
Aggregates tasks that assemble the specific variant of this application.

[[sec:cpp_application_lifecycle_tasks]]
=== Lifecycle Tasks

The {cpp} Application Plugin attaches some of its tasks to the standard lifecycle tasks documented in the <<base_plugin.adoc#base_plugin,Base Plugin chapter>> - which the {cpp} Application Plugin applies automatically:

`assemble` - Task (lifecycle)::
Depends on: `linkDebug`
::

class NativeBasePluginIntegrationTest extends AbstractIntegrationSpec {
    def "assemble does nothing when no other plugins applied"() {
        given:
        buildFile << """
            apply plugin: NativeBasePlugin
"""

        when:
        run "assemble"

        then:
        result.assertTasksExecuted(":assemble")
    }

            headerChange = \${defaults} {
              tasks = ["assemble"]
              apply-h-change-to = "${headerFile}"
            }

            cppFileChange = \${defaults} {
              tasks = ["assemble"]
              apply-cpp-change-to = "${cppFile}"
            }

            assemble = \${defaults} {
              tasks = ["assemble"]
            }

            cleanAssemble = \${assemble} {

import spock.lang.Specification

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

    def "assembles schema for a Set of scalar type"() {
        expect:
        def schema = store.getSchema(ModelTypes.set(ModelType.of(String)))
        schema instanceof ScalarCollectionSchema
        schema instanceof ManagedImplSchema

        tools.put(ToolType.STATIC_LIB_ARCHIVER, instantiator.newInstance(DefaultCommandLineToolConfiguration.class, ToolType.STATIC_LIB_ARCHIVER));
        tools.put(ToolType.ASSEMBLER, instantiator.newInstance(DefaultCommandLineToolConfiguration.class, ToolType.ASSEMBLER));
        tools.put(ToolType.WINDOW_RESOURCES_COMPILER, instantiator.newInstance(DefaultCommandLineToolConfiguration.class, ToolType.WINDOW_RESOURCES_COMPILER));
    }

    @Override