false                     | _
        true                      | _
    }

    def "uses the default configuration when producer is not a library"() {
        given:
        subproject('a') {
            'build.gradle'('''
                apply plugin: 'java-library'
                dependencies {
                    api project(':b')
                }
            ''')
            src {
                main {

                dependencies {
                    implementation project(':greeter')
                }
            }
            project(':greeter') {
                apply plugin: 'swift-library'
            }
"""
        app.library.writeToProject(file("greeter"))
        app.application.writeToProject(file("app"))

        when:
        succeeds "assemble"

        then:

    }

    @ToBeFixedForConfigurationCache
    def "can create xcode project for Swift static library"() {
        requireSwiftToolChain()

        given:
        buildFile << """
            apply plugin: 'swift-library'
            library.linkage = [Linkage.STATIC]
        """
        def lib = new SwiftLib()
        lib.writeToProject(testDirectory)

        when:

    @ToBeFixedForConfigurationCache
    def "can depend on header-only library composed of generated sources"() {
        given:
        // Write sources to src/main, headers to src/hello
        def app = new CHelloWorldApp()
        app.executable.writeSources(file("src/main"))
        app.library.sourceFiles*.writeToDir(file("src/main"))
        app.library.headerFiles*.writeToDir(file("src/input"))
        degenerateInputSources()

    }

    def "Java Library can depend on feature of component [compileClasspathPackaging=#compileClasspathPackaging]"() {
        toggleCompileClasspathPackaging(compileClasspathPackaging)
        settingsFile << """
            include 'b', 'c', 'd', 'e', 'f', 'g'
        """
        given:
        file("b/build.gradle") << """
            apply plugin: 'java-library'

            group = 'org.gradle.test'

 * Shared and static library files are published directly to Maven repositories along with a zip of the public headers.
 * For applications, Gradle also supports installing and running the executable with all of its shared library dependencies in a known location.

[[sec:cleaning_swift_build]]
== Cleaning the build

        }
    }

    def "publish and resolve java-library with dependency on java-platform (named #platformName)"() {
        given:
        javaLibrary(mavenRepo.module("org.test", "foo", "1.0")).withModuleMetadata().publish()
        javaLibrary(mavenRepo.module("org.test", "bar", "1.1")).withModuleMetadata().publish()

        createDirs(platformName, "library")
        settingsFile << """
include "$platformName", "library"

                exampleClass = if (descriptor.componentType === ComponentType.LIBRARY) "Hello" else "Greeter"
                sourceFile = (if (descriptor.componentType === ComponentType.LIBRARY) "hello" else "app") + ".cpp"
                testSourceFile = (if (descriptor.componentType === ComponentType.LIBRARY) "hello" else "app") + "_test.cpp"
                sourceFileTree = """        │   │   └── $sourceFile

        when:
        services.configureAttributes(Stub(HasConfigurableAttributes) { getAttributes() >> attrs }) {
            it.library()
        }

        then:
        attrs.asMap() == [
            (CATEGORY_ATTRIBUTE): named(Category, LIBRARY)
        ]

        when:
        attrs = AttributeTestUtil.attributesFactory().mutable()

            sources {
                cpp.lib library: 'hello'
            }
        }
    }
}
"""

        and:
        fails "mainExecutable"

        then:
        failure.assertHasDescription("Could not determine the dependencies of task ':linkMainExecutable'.")