*/
  private static final SuccessorsFunction<Character> TWO_CYCLES_GRAPH =
      createDirectedGraph("ab", "ac", "bc", "cd", "da");

  /**
   * A tree-shaped graph that looks as follows (all edges are directed facing downwards):
   *
   * <pre>{@code
   *        h
   *       /|\
   *      / | \
   *     /  |  \
   *    d   e   g
   *   /|\      |
   *  / | \     |
   * a  b  c    f
   * }</pre>

   */
  private static final SuccessorsFunction<Character> TWO_CYCLES_GRAPH =
      createDirectedGraph("ab", "ac", "bc", "cd", "da");

  /**
   * A tree-shaped graph that looks as follows (all edges are directed facing downwards):
   *
   * <pre>{@code
   *        h
   *       /|\
   *      / | \
   *     /  |  \
   *    d   e   g
   *   /|\      |
   *  / | \     |
   * a  b  c    f
   * }</pre>

import spock.lang.Retry
import spock.lang.Timeout

@Ignore
class ToolingApiShutdownIntegrationTest extends AbstractIntegrationSpec {

    @Retry(count = 3)
    @Timeout(30)
    def "tooling api can disconnect from hanging daemon"() {
        setup:
        settingsFile << "rootProject.name = 'client-runner'"
        buildFile << """
            plugins {
                id 'java'
            }

            repositories {

 * Fix: Properly handle exceptions from `NetworkInterface` when querying MTU.
 * Fix: Ensure MTU has a reasonable default and upper-bound.


## Version 1.0.1

_2013-05-06_

 * Correct casing of SSL in method names (`getSslSocketFactory`/`setSslSocketFactory`).


## Version 1.0.0

_2013-05-06_

            }
        } finally {
            httpExchange.close();
        }
    }

    // Dump all JVMs' threads on the machine to troubleshoot deadlock issues
    // We observed jstack hanging on windows, so for now we only enable it for Linux
    private void dumpThreadsUponTimeout(String stacktrace) {
        if (stacktrace.contains("due to a timeout waiting for other requests") && OperatingSystem.current().isLinux()) {

import org.gradle.internal.reflect.Instantiator;

/**
 * Default implementation of {@link ResolutionOutputsInternal}. This class is in charge of
 * converting internal results in the form of {@link ResolverResults} into public facing types like:
 *
 * <ul>
 *     <li>{@link org.gradle.api.file.FileCollection}</li>
 *     <li>{@link org.gradle.api.artifacts.ArtifactCollection}</li>
 *     <li>{@link org.gradle.api.artifacts.ArtifactView}</li>

      verifyHostname(hostname, it)
    }
  }

  /**
   * This is like [toLowerCase] except that it does nothing if this contains any non-ASCII
   * characters. We want to avoid lower casing special chars like U+212A (Kelvin symbol) because
   * they can return ASCII characters that match real hostnames.
   */
  private fun String.asciiToLowercase(): String {
    return when {

    // If this test becomes flaky it means we broke the code which prevents mutation of in-memory cached module metadata
    def "selected variants are consistent using concurrent resolution of graphs from cache having different derivation strategies"() {
        executer.requireOwnGradleUserHomeDir()
        settingsFile << """
            include 'app'
            include 'lib'
        """

        buildFile << """

// we only expose some functions to external users for simplicity.
type internalCollection[T any] interface {
	Collection[T]

	// Name is a human facing name for this collection.
	// Note this may not be universally unique
	name() string
	// Uid is an internal unique ID for this collection. MUST be globally unique
	uid() collectionUID

	dump()

		return nil, err
	}

	return &security.Caller{
		AuthSource: security.AuthSourceClientCertificate,
		Identities: ids,
	}, nil
}

// authenticateHTTP performs mTLS authentication for http requests. Requires having the endpoints on a listener
// with proper TLS configuration.
func (cca *ClientCertAuthenticator) authenticateHTTP(req *http.Request) (*security.Caller, error) {
	if req.TLS == nil || req.TLS.VerifiedChains == nil {