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

    val chain = newChain(call)
    return RealRoutePlanner(
      taskRunner = client.taskRunner,
      connectionPool = client.connectionPool.delegate,
      readTimeoutMillis = client.readTimeoutMillis,
      writeTimeoutMillis = client.writeTimeoutMillis,
      socketConnectTimeoutMillis = chain.connectTimeoutMillis,
      socketReadTimeoutMillis = chain.readTimeoutMillis,

type ExpectedRealServer struct {
	IP   string
	Port uint16
}

// ExpectedIptablesChain is a map of expected iptables chain and jump rules
type ExpectedIptablesChain map[string][]ExpectedIptablesRule

// ExpectedIptablesRule is the expected iptables rules with jump chain and match ipset name
type ExpectedIptablesRule struct {
	SourceAddress string
	JumpChain     string
	MatchSet      string
}

			expectedErr:    "failed to parse root certificate",
		},
		"Cert chain bad": {
			privPem:        nil,
			certChainPem:   []byte(certChainBad),
			rootCertPem:    []byte(rootCert),
			expectedFields: verifyField1,
			expectedErr:    "failed to parse certificate chain",
		},
		"Failed to verify cert chain": {
			privPem:        nil,
			certChainPem:   []byte(certChainNoRoot),

            converter = new LangAnayzerConverter(null);
        } else {
            final ReadingConverterChain chain = new ReadingConverterChain();
            for (final String lang : langs) {
                chain.addConverter(new LangAnayzerConverter(lang));
            }
            converter = chain;
        }
        return converter.convert(text, field);
    }

 * limitations under the License.
 */

package org.gradle.nativeplatform.toolchain;

import org.gradle.api.Action;
import org.gradle.api.Incubating;

import java.io.File;

/**
 * The Visual C++ tool chain.
 */
@Incubating
public interface VisualCpp extends NativeToolChain {
    /**
     * The directory where Visual Studio or Visual C++ is installed.
     */
    File getInstallDir();

    /**

	Identifier string
	Comment    string
}

var (
	JumpInbound             = Command{"JumpInbound", "direct all traffic through ISTIO_INBOUND chain"}
	JumpOutbound            = Command{"JumpOutbound", "direct all traffic through ISTIO_OUTBOUND chain"}
	ExcludeInboundPort      = Command{"ExcludeInboundPort", "exclude inbound port from capture"}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        CountDownLatch latch = new CountDownLatch(1);
        try {
            latch.await(blockForSeconds, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            // ignore
        }
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
    }

            @Override
            void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
                assert request.getHeader("X-Gradle-Version") == GradleVersion.current().version
                chain.doFilter(request, response)
            }

            @Override
            void destroy() {}

        fails('assemble')

        and:
        failure.assertHasDescription("Execution failed for task ':compileDebugSwift'.")
        failure.assertHasCause("""No tool chain is available to build Swift for host operating system '${osName}' architecture '${archName}':
  - Tool chain '${toolChain.id}' (Swift Compiler):
      - Could not determine SwiftC metadata: swiftc produced unexpected output.""")
    }