.publish()
        buildFile << """
            dependencies {
                testImplementation(testFixtures('com.acme:external-module:1.3'))
            }
            repositories {
                maven {
                    url "${mavenRepo.uri}"
                }
            }
        """
        when:
        def resolve = new ResolveTestFixture(buildFile, "testCompileClasspath")

        given:
        buildFile << """
            apply plugin: 'java'

            task expect {
                assert project.components.mainComponent.get() == components.java
            }
        """

        expect:
        succeeds "expect"
    }

    def "Java plugin adds outgoing variant for main source set"() {
        buildFile << """
            plugins {
                id 'java'

        def app = new SwiftApp()
        settingsFile << "rootProject.name = 'app'"
        app.writeToProject(testDirectory)
        buildFile << """
            apply plugin: 'swift-application'
         """

        outputs.snapshot { succeeds("compileDebugSwift") }

        buildFile << """
            tasks.withType(SwiftCompile) {
                compilerArgs.add('-Onone')
            }
        """

        }
    }

    @Requires(UnitTestPreconditions.HasXCode)
    @ToBeFixedForConfigurationCache
    def "returns meaningful errors from xcode when component product is unbuildable due to operating system"() {
        useXcodebuildTool()

        given:
        makeSingleProject()
        buildFile << configureTargetMachines("machines.os('os-family')")

    def buildOperations = new BuildOperationsFixture(executer, temporaryFolder)

    def "can create and use a work action defined in buildSrc in #isolationMode"() {
        fixture.withWorkActionClassInBuildSrc()

        buildFile << """
            task runInWorker(type: WorkerTask) {
                isolationMode = $isolationMode
            }
        """

        when:
        succeeds("runInWorker")

        then:

@RequiresInstalledToolChain(ToolChainRequirement.SWIFTC)
class SwiftLibraryIntegrationTest extends AbstractInstalledToolChainIntegrationSpec {
    def "skip compile and link tasks when no source"() {
        given:
        buildFile << """
            apply plugin: 'swift-library'
        """

        expect:
        succeeds "assemble"
        result.assertTasksExecuted(":compileDebugSwift", ":linkDebug", ":assemble")

        given:
        def testScript = ShellScript.builder()
            .printArguments()
            .printEnvironmentVariable("TEST_FOO")
            .writeTo(testDirectory, "script")

        buildFile """
            def execProvider = providers.exec {
                ${cmdToExecConfig(*testScript.commandLine, "--some-arg")}
                environment("TEST_FOO", "fooValue")
            }

class ComponentBinarySourcesIntegrationTest extends AbstractComponentModelIntegrationTest {
    def setup() {
        withCustomComponentType()
        withCustomBinaryType()
        withCustomLanguageType()

        buildFile << '''
model {
    components {
        mylib(CustomComponent) {
            binaries {
                main(CustomBinary)
                test(CustomBinary)
            }
        }
    }
}
'''

        given:
        def javaProject = new StaleOutputJavaProject(testDirectory, buildDirName)
        buildFile << "apply plugin: 'java'"

        if (!defaultDir) {
            buildFile << """
                buildDir = '$javaProject.buildDirName'
            """
        }

        when:
        result = runWithMostRecentFinalRelease(JAR_TASK_NAME)

        when:
        succeeds "test"

        then:
        skipped ':test'

        // Keep the same files, but move one of them to the other property
        buildFile.delete()
        buildFile << """
            task test(type: TaskWithTwoOutputDirectoriesProperties) {
                outputs1 = file("\$buildDir/output2")
                outputs2 = file("\$buildDir/output1")
            }