}

    @Requires(UnitTestPreconditions.CanInstallExecutable)
    @RequiresInstalledToolChain(ToolChainRequirement.GCC)
    @ToBeFixedForConfigurationCache
    def "can build with multiple tool chains"() {
        AvailableToolChains.InstalledToolChain x86ToolChain = OperatingSystem.current().isWindows() ?
                AvailableToolChains.getToolChain(ToolChainRequirement.VISUALCPP) :

	// Inversion is implemented as exponentiation by n - 2, per Fermat's little theorem.
	//
	// The sequence of 38 multiplications and 254 squarings is derived from
	// https://briansmith.org/ecc-inversion-addition-chains-01#p256_scalar_inversion
	_1 := new(p256OrdElement)
	_11 := new(p256OrdElement)
	_101 := new(p256OrdElement)
	_111 := new(p256OrdElement)
	_1111 := new(p256OrdElement)
	_10101 := new(p256OrdElement)

                U result = mapper.apply(value);
                return Objects.requireNonNull(result, "Mapping a Deferrable to null is not allowed");
            }
        };
    }

    /**
     * Chains two {@link Deferrable}s.
     *
     * @param mapper A function which creates the next {@link Deferrable} from the result of the first one.

	}
	cert, err := ParsePemEncodedCertificate(certBytes)
	if err != nil {
		return fmt.Errorf("failed to parse cert PEM: %v", err)
	}
	chains, err := cert.Verify(opts)

	if len(chains) == 0 || err != nil {
		return fmt.Errorf(
			"cannot verify the cert with the provided root chain and cert "+
				"pool with error: %v", err)
	}

	// Verify that the key can be correctly parsed.

import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import junit.framework.TestCase;

/**
 * Unit tests for any listenable future that chains other listenable futures. Unit tests need only
 * override buildChainingFuture and getSuccessfulResult, but they can add custom tests as needed.
 *
 * @author Nishant Thakkar
 */

    @Rule public final Sample variants = sample(testDirectoryProvider, 'variants')
    @Rule public final Sample toolChains = sample(testDirectoryProvider, 'tool-chains')
    @Rule public final Sample prebuilt = sample(testDirectoryProvider, 'prebuilt')
    @Rule public final Sample targetPlatforms = sample(testDirectoryProvider, 'target-platforms')

            }
        }

        public int hashCode() {
            return this.keys.hashCode();
        }
    }

    /**
     * chains a collection of {@link WorkspaceReader}s
     * @param workspaceReaderCollection the collection of readers, might be empty but never <code>null</code>

	}

	// Then generate the per-port passthrough filter chains.
	for port := range b.applier.PortLevelSetting() {
		// Skip the per-port passthrough filterchain if the port is already handled by InboundMTLSConfiguration().
		if !needPerPortPassthroughFilterChain(port, b.proxy) {
			continue
		}

		authnLog.Debugf("InboundMTLSConfiguration: build extra pass through filter chain for %v:%d", b.proxy.ID, port)

            getTextOutput().withStyle(Description).println(cause.getMessage());
            reportedCauseLines++;

            cause = cause.getCause();

            // Protect against excessively long cause-chains in the outputs.
            if (reportedCauseLines == INVALID_TOOLCHAIN_ERROR_CAUSE_LIMIT && cause != null) {
                // Ellipsize the omitted cause lines:

      }
    }
  }

  /**
   * Not checking the CA bit created a vulnerability in old OkHttp releases. It is exploited by
   * triggering different chains to be discovered by the TLS engine and our chain cleaner. In this
   * attack there's several different chains.
   *
   *
   * The victim's gets a non-CA certificate signed by a CA, and pins the CA root and/or
   * intermediate. This is business as usual.
   *