)

// Specific instances for EC256 and company
var (
	SigningMethodES3256 *jwt.SigningMethodECDSA
	SigningMethodES3384 *jwt.SigningMethodECDSA
	SigningMethodES3512 *jwt.SigningMethodECDSA
)

func init() {
	// ES256
	SigningMethodES3256 = &jwt.SigningMethodECDSA{Name: "ES3256", Hash: crypto.SHA3_256, KeySize: 32, CurveBits: 256}
	jwt.RegisterSigningMethod(SigningMethodES3256.Alg(), func() jwt.SigningMethod {

class BasicTrustRootIndex(
  vararg caCerts: X509Certificate,
) : TrustRootIndex {
  private val subjectToCaCerts: Map<X500Principal, Set<X509Certificate>>

  init {
    val map = mutableMapOf<X500Principal, MutableSet<X509Certificate>>()
    for (caCert in caCerts) {
      map.getOrPut(caCert.subjectX500Principal) { mutableSetOf() }.add(caCert)
    }
    this.subjectToCaCerts = map

    private String realm;

    /** The CIFS context for transport operations */
    private CIFSContext transportContext;

    @Override
    public void init(final ServletConfig config) throws ServletException {
        super.init(config);

        final Properties p = new Properties();
        p.putAll(System.getProperties());
        /*

import common.getBuildScanCustomValueParam
import model.CIBuildModel
import model.Stage

class BuildLogicTest(
    model: CIBuildModel,
    stage: Stage,
) : OsAwareBaseGradleBuildType(os = Os.LINUX, stage = stage, init = {
        id(buildTypeId(model))
        name = "Build-logic checks"
        description = "Run check on all build-logic builds"

        features {
            publishBuildStatusToGithub(model)
        }

import jetbrains.buildServer.configs.kotlin.BuildSteps
import model.CIBuildModel
import model.Stage

class TestPerformanceTest(
    model: CIBuildModel,
    stage: Stage,
) : OsAwareBaseGradleBuildType(os = Os.LINUX, stage, init = {
        val os = Os.LINUX
        val buildTypeThis = this
        val testProject = "smallJavaMultiProject"

        fun BuildSteps.gradleStep(tasks: List<String>) {
            gradleWrapper {

  }

  CompactLinkedHashMap(int expectedSize, boolean accessOrder) {
    super(expectedSize);
    this.accessOrder = accessOrder;
  }

  @Override
  void init(int expectedSize) {
    super.init(expectedSize);
    this.firstEntry = ENDPOINT;
    this.lastEntry = ENDPOINT;
  }

  @Override
  int allocArrays() {
    int expectedSize = super.allocArrays();

	shuffledPartsMetadata = make([]FileInfo, len(partsMetadata))
	distribution := fi.Erasure.Distribution

	init := fi.ModTime.IsZero()
	// Shuffle slice xl metadata for expected distribution.
	for index := range partsMetadata {
		if disks[index] == nil {
			continue
		}
		if !init && !partsMetadata[index].IsValid() {
			// Check for parts metadata validity for only

    /**
     * Creates a new GcsClient instance.
     */
    public GcsClient() {
        super();
    }

    @Override
    public synchronized void init() {
        if (isInit) {
            return;
        }

        super.init();

        final String projectId = getInitParameter("projectId", null, String.class);
        if (StringUtil.isBlank(projectId)) {

        StorageClient client = new StorageClient() {
            @Override
            protected ResponseData processRequest(final String uri, final boolean includeContent) {
                // Skip init() and directly test timeout handling
                org.codelibs.fess.crawler.client.AccessTimeoutTarget accessTimeoutTarget = null;
                org.codelibs.core.timer.TimeoutTask accessTimeoutTask = null;

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      private val client: OkHttpClient

      init {
        val trustManager = trustManagerForCertificates(trustedCertificatesInputStream())
        val sslContext = SSLContext.getInstance("TLS")
        sslContext.init(null, arrayOf<TrustManager>(trustManager), null)
        val sslSocketFactory = sslContext.socketFactory