),
    ],
    swiftLanguageVersions: [3]
)
"""
        swiftPmBuildSucceeds()
    }

    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def "honors customizations to Swift module name"() {
        given:
        createDirs("lib1", "lib2")
        settingsFile << "include 'lib1', 'lib2'"
        buildFile << """
            plugins {

		return err
	}

	// drop init container annotations so they don't take effect on legacy kubelets.
	// remove this once the oldest supported kubelet no longer honors the annotations over the field.
	out.Annotations = dropInitContainerAnnotations(out.Annotations)

	return nil
}

set before starting MinIO server. After the data and parity drives for each storage class are defined using environment variables,
you can set the storage class of an object via request metadata field `x-amz-storage-class`. MinIO server then honors the storage class by
saving the object in specific number of data and parity drives.

## Storage usage

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                edge("org:foo:{require 1.0; reject 1.1}", "org:foo:1.0")
            }
        }
    }

    void "honors rejection using dynamic versions using dependency notation #notation"() {
        given:
        repository {
            'org:foo:1.0' {
                withModule(IvyModule) {
                    withStatus('release')

                public void start(Stage stage) {
                }
            }
        """

        expect:
        succeeds("compileJava")
    }

    def "honors project level compatibility when using toolchain"() {
        given:
        def lower = getLowerJvm()
        def lowerVersion = lower.javaVersion.getMajorVersion()

        and:
        goodCode()

   Dependency path ':test:unspecified' --> 'org:foo:1.1'
   Dependency path ':test:unspecified' --> 'org:bar:1.0' (runtime) --> 'org:foo:{require 1.0; reject 1.1}'""")
    }

    void "honors multiple rejections #rejects using dynamic versions using dependency notation #rejects"() {
        given:
        repository {
            (0..5).each {
                "org:foo:1.$it"()
            }

     * will fail with a `504 Unsatisfiable Request`.
     */
    @JvmField
    val FORCE_CACHE = commonForceCache()

    /**
     * Returns the cache directives of [headers]. This honors both Cache-Control and Pragma headers
     * if they are present.
     */
    @JvmStatic
    fun parse(headers: Headers): CacheControl = commonParse(headers)
  }

        succeeds("xcode")

        then:
        rootXcodeProject.projectFile.sources.assertHasChildren(lib.files*.name)
    }

    @ToBeFixedForConfigurationCache
    def "honors changes to executable output file locations"() {
        requireSwiftToolChain()

        given:
        buildFile << """
            apply plugin: 'swift-application'
            buildDir = 'output'

        installation.assertIncludesLibraries()
        installation.exec().out == app.expectedOutput
    }

    @ToBeFixedForConfigurationCache
    def "honors changes to library buildDir"() {
        createDirs("app", "lib1", "lib2")
        settingsFile << "include 'app', 'lib1', 'lib2'"
        def app = new CppAppWithLibraries()

        given:
        buildFile << """

        rootXcodeProject.projectFile.headers.assertHasChildren(lib.headers.files*.name)
    }

    @ToBeFixedForConfigurationCache
    def "honors changes to application output locations"() {
        given:
        buildFile << """
            apply plugin: 'cpp-application'
            buildDir = 'output'
            application.baseName = 'test_app'