}

  /**
   * Gets a {@code Throwable} cause chain as a list. The first entry in the list will be {@code
   * throwable} followed by its cause hierarchy. Note that this is a snapshot of the cause chain and
   * will not reflect any subsequent changes to the cause chain.
   *
   * <p>Here's an example of how it can be used to find specific types of exceptions in the cause
   * chain:
   *
   * <pre>

        0 * attributeMatcher._
    }

    private void assertTransformChain(TransformedVariant chain, ResolvedVariant source, AttributeContainer finalAttributes, TransformRegistration... registrations) {
        assert chain.root == source
        assert chain.attributes == finalAttributes
        def actualSteps = []
        chain.transformChain.visitTransformSteps {
            actualSteps << it
        }

OdHOim9+
-----END PRIVATE KEY-----
```

Recommendations
---------------

Typically servers need a held certificate plus a chain of intermediates. Servers only need the
private key for their own certificate. The chain served by a server doesn't need the root
certificate.

The trusted roots don't need to be the same for client and server when using client authentication.

import org.gradle.api.file.ContentFilterable

import java.io.FilterReader
import kotlin.reflect.KClass


/**
 * Adds a content filter to be used during the copy.
 * Multiple calls add additional filters to the filter chain.
 * Each filter should implement [FilterReader].
 * Import `org.apache.tools.ant.filters.*` for access to all the standard Ant filters.
 *
 * Examples:
 *
 * ```
 * filter<StripJavaComments>()

import org.gradle.api.Incubating;
import org.gradle.nativeplatform.platform.NativePlatform;

/**
 * A platform specific configurable tool chain.
 */
@Incubating
public interface NativePlatformToolChain {
    /**
     * Returns the platform which this tool chain builds for.
     */
    NativePlatform getPlatform();

import okhttp3.internal.stripBody
import okio.buffer

/** This is the last interceptor in the chain. It makes a network call to the server. */
class CallServerInterceptor(private val forWebSocket: Boolean) : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val realChain = chain as RealInterceptorChain
    val exchange = realChain.exchange!!
    val request = realChain.request

    def "QUIET and below are dispatched to the stdout chain"() {
        when:
        dispatcher.onOutput(event(logLevel))

        then:
        1 * stdoutChain.onOutput(_)
        0 * stderrChain.onOutput(_)

        where:
        logLevel << LogLevel.values() - LogLevel.ERROR
    }

    def "ERROR is dispatched to the stderr chain"() {
        when:
        dispatcher.onOutput(event(LogLevel.ERROR))

        app.writeToProject(testDirectory)

        when:
        fails "check"
        then:
        failure.assertHasCause("""No tool chain is available to build Swift for host operating system '${osName}' architecture '${archName}':
  - Tool chain 'swiftc' (Swift Compiler):
      - Could not find Swift compiler 'swiftc' in system path.""")
    }

        expect:
        project.plugins.hasPlugin(pluginClass)
    }

    def "makes a VisualCpp tool chain available"() {
        when:
        register()

        then:
        toolchain instanceof VisualCppToolChain
    }

    def "registers default VisualCpp tool chain"() {
        when:
        addDefaultToolchain()

        then:
        toolchain instanceof VisualCppToolChain
    }

    }

    public void setFile(File file) {
        this.file = file;
    }

    /**
     * The Tool Chain that produces the native executable.
     * @since 4.7
     */
    public NativeToolChain getToolChain() {
        return toolChain;
    }

    /**
     * Sets the Tool Chain that produces the native executable.
     * @since 4.7
     */
    public void setToolChain(NativeToolChain toolChain) {