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

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

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

		}
	}
}

func validateFilterChainMatch(t testing.TB, l *listener.Listener) {
	t.Helper()

	// Check for duplicate filter chains, to avoid "multiple filter chains with the same matching rules are defined" error
	check := map[string]int{}
	for i1, l1 := range l.FilterChains {
		// We still create virtual inbound listeners before merging into single inbound

    String getExecutableName(String executablePath);

    String getSharedLibraryName(String libraryPath);

    /**
     * Does this tool chain produce an import library when linking a shared library?
     */
    boolean producesImportLibrary();

    /**
     * Whether or not this tool chain requires a debuggable binary to be stripped or whether the binary is stripped by default.
     */
    boolean requiresDebugBinaryStripping();