// A Property may wrap the provider in the type-adapting one, adding an extra item to the evaluation chain.
            // To account for this, we only check the beginning of the chain, and its last element.
            assert ex.evaluationCycle[0..1] == [provider, property]
            assert ex.evaluationCycle.last() == provider
        }
    }

    /**

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>()

          }
        }
      }
    };

    OkHttpClient client = new OkHttpClient.Builder()
        .addNetworkInterceptor(chain -> {
          Response originalResponse = chain.proceed(chain.request());
          return originalResponse.newBuilder()
              .body(new ProgressResponseBody(originalResponse.body(), progressListener))
              .build();
        })

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

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();

        fallback.attribute(one, "fallback")

        then:
        chain.getAttribute(one) == "fallback"

        when:
        middle.attribute(one, "middle")

        then:
        chain.getAttribute(one) == "middle"

        when:
        primary.attributeProvider(one, Providers.of("primary"))

        then:
        chain.getAttribute(one) == "primary"
    }

    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.""")
    }

    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#chain(jcifs.internal.smb2.ServerMessageBlock2)
     */
    @Override
    public boolean chain ( ServerMessageBlock2 n ) {
        n.setSessionId(Smb2Constants.UNSPECIFIED_SESSIONID);
        return super.chain(n);
    }


    /**
     * {@inheritDoc}
     *