.apply {
            init(null as KeyStore?)
          }.trustManagers
          .first() as X509TrustManager

      val sslContext =
        Platform.get().newSSLContext().apply {
          // TODO remove most of this code after https://github.com/bcgit/bc-java/issues/686
          init(null, arrayOf(trustManager), SecureRandom())
        }

      client =

  val defaultValue: T? = null,
  /** True to set the encoded or decoded value as the type hint for the current SEQUENCE. */
  private val typeHint: Boolean = false,
) : DerAdapter<T> {
  init {
    require(tagClass >= 0)
    require(tag >= 0)
  }

  override fun matches(header: DerHeader): Boolean = header.tagClass == tagClass && header.tag == tag

  override fun fromDer(reader: DerReader): T {

	sqlserverDSN = "sqlserver://sa:LoremIpsum86@localhost:9930?database=master"
	tidbDSN      = "root:@tcp(localhost:9940)/test?charset=utf8&parseTime=True&loc=Local"
)

func init() {
	var err error
	if DB, err = OpenTestConnection(&gorm.Config{}); err != nil {
		log.Printf("failed to connect database, got error %v", err)
		os.Exit(1)
	} else {
		sqlDB, err := DB.DB()
		if err != nil {

        if (!text) return '';
        var div = document.createElement('div');
        div.textContent = text;
        return div.innerHTML;
    }

    // Public API
    return {
        init: init
    };

  CompactHashSet() {
    init(CompactHashing.DEFAULT_SIZE);
  }

  /**
   * Constructs a new instance of {@code CompactHashSet} with the specified capacity.
   *
   * @param expectedSize the initial capacity of this {@code CompactHashSet}.
   */
  CompactHashSet(int expectedSize) {
    init(expectedSize);
  }

  /** Pseudoconstructor for serialization support. */

var localMetacacheMgr = &metacacheManager{
	buckets: make(map[string]*bucketMetacache),
	trash:   make(map[string]metacache),
}

type metacacheManager struct {
	mu      sync.RWMutex
	init    sync.Once
	buckets map[string]*bucketMetacache
	trash   map[string]metacache // Recently deleted lists.
}

const metacacheMaxEntries = 5000

// initManager will start async saving the cache.

class PerformanceTestsPass(
    model: CIBuildModel,
    performanceTestProject: PerformanceTestProject,
) : OsAwareBaseGradleBuildType(
        os = Os.LINUX,
        failStage = performanceTestProject.spec.failsStage,
        init = {
            id("${performanceTestProject.spec.asConfigurationId(model)}_Trigger")
            val performanceTestSpec = performanceTestProject.spec
            name = performanceTestProject.name + " (Trigger)"

        } catch (ignore: Exception) {
        }
      }
      return ISO_8859_1
    }

  constructor(scheme: String, realm: String) : this(scheme, singletonMap("realm", realm))

  init {
    val newAuthParams = mutableMapOf<String?, String>()
    for ((key, value) in authParams) {
      val newKey = key?.lowercase(US)
      newAuthParams[newKey] = value
    }

    val testProjects: List<String>,
    val bucketIndex: Int,
    extraParameters: String = "",
    performanceTestTaskSuffix: String = "PerformanceTest",
    preBuildSteps: BuildSteps.() -> Unit = {},
) : BaseGradleBuildType(
        stage = stage,
        init = {
            this.id(performanceTestBuildSpec.asConfigurationId(model, "bucket${bucketIndex + 1}"))
            this.name = description
            val type = performanceTestBuildSpec.type

          SSLContext.getInstance("TLS")
        }
      }
    }

  companion object {
    val isAvailable: Boolean

    val majorVersion = System.getProperty("java.specification.version")?.toIntOrNull()

    init {
      isAvailable =
        if (majorVersion != null) {
          majorVersion >= 9
        } else {
          try {
            // also present on JDK8 after build 252.