class SwiftPackageManagerSwiftBuildExportIntegrationTest extends AbstractSwiftPackageManagerExportIntegrationTest {

    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def "produces manifest for single project Swift library that defines only the production targets"() {
        given:
        buildFile << """
            plugins {
                id 'swiftpm-export'

# Regression test for Issue #54908. When running a go install module@version
# with --mod=readonly moduleInfo was not setting the GoVersion for the module
# because the checksumOk function was failing because modfetch.GoSumFile
# was not set when running outside of a module.

env GOTOOLCHAIN=local

      log.put("failing task running")
      throw RuntimeException("boom!")
    }

    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(200)) {
      log.put("normal task running")
      return@schedule -1L
    }

    queue.idleLatch().await(500, TimeUnit.MILLISECONDS)

    assertThat(log.take()).isEqualTo("failing task running")

import java.io.FilterReader


/**
 * Adds a content filter to be used during the copy.
 *
 * @see [CopySpec.filter]
 */
inline fun <reified T : FilterReader> CopySpec.filter(vararg properties: Pair<String, Any?>) =
    filter(mapOf(*properties), T::class.java)


/**
 * Adds a content filter to be used during the copy.
 *
 * @see [CopySpec.filter]
 */

 * Note that this implementation currently retains strong references to keys and values during the whole lifetime of a build session.
 *
 * Uses a simple algorithm to collect unused values, by retaining strong references to all keys and values used during the current build session, and the previous build session.
 * All other values are referenced only by weak or soft references, allowing them to be collected.

Any direct modification or reading of another project's object creates coupling between the projects.
Coupling during configuration can result in flawed build outcomes when using 'configuration on demand', while coupling during execution can affect parallel execution.

One common source of coupling is configuration injection, such as using `allprojects{}` or `subprojects{}` in build scripts.

To avoid coupling issues, it's recommended to:

    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def "can configure the location of the generated manifest file"() {
        given:
        buildFile << """
            plugins {
                id 'swiftpm-export'
                id 'swift-library'
            }
            tasks.generateSwiftPmManifest.manifestFile = file('generated/thing.swift')
"""

        when:

)

// This file contains a definition of the type-checking context; an opaque type
// that may be supplied by users during instantiation.
//
// Contexts serve two purposes:
//  - reduce the duplication of identical instances
//  - short-circuit instantiation cycles
//
// For the latter purpose, we must always have a context during instantiation,
// whether or not it is supplied by the user. For both purposes, it must be the

	)

	// InstanceErrs is a measure of the number of errors for processing instance config.
	InstanceErrs = monitoring.NewGauge(
		"mixer/config/instance_config_errors_total",
		"The number of errors encountered during processing of the instance configuration.",
	)

	// RulesTotal is a measure of the number of known rules.
	RulesTotal = monitoring.NewGauge(
		"mixer/config/rule_configs_total",

        // depending on JVM version, the error might occur either during SSL context initialization or during request
        if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_18)) {
            failure.assertHasCause("Got SSL handshake exception during request. It might be caused by SSL misconfiguration")
        } else {