)

class StageTriggers(model: CIBuildModel, stage: Stage, prevStage: Stage?, stageProject: StageProject) {
    val triggers: List<BaseGradleBuildType>

    init {
        triggers = mutableListOf()
        val allDependencies =
            stageProject.specificBuildTypes + stageProject.performanceTests + stageProject.functionalTests + stageProject.docsTestTriggers

 */
open class DelegatingSSLSocketFactory(private val delegate: SSLSocketFactory) : SSLSocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): SSLSocket {
    val sslSocket = delegate.createSocket() as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
  ): SSLSocket {

      .isNotNull()
    val effectivePort =
      when {
        url!!.port != defaultPort(url.scheme) -> Integer.toString(url.port)
        else -> ""
      }
    val effectiveQuery =
      when {
        url.encodedQuery != null -> "?" + url.encodedQuery
        else -> ""
      }
    val effectiveFragment =
      when {

        started = true;
        isFocusList = false;
      } else if (e.keyCode === 38) {
        /*			if($boxElement.css("display") !== "none") {
				var strTmp = $textArea.val();
				$textArea.val("");
				$textArea.focus();
				$textArea.val(strTmp);
			} */
      }
    });
    $(this).blur(function() {
      if (!isMouseHover) {
        suggestor.fixList();
      }
    });

    };

    static void writeInt2( long val, byte[] dst, int dstIndex ) {
        dst[dstIndex] = (byte)(val);
        dst[++dstIndex] = (byte)(val >> 8);
    }
    static void writeInt4( long val, byte[] dst, int dstIndex ) {
        dst[dstIndex] = (byte)(val);
        dst[++dstIndex] = (byte)(val >>= 8);
        dst[++dstIndex] = (byte)(val >>= 8);
        dst[++dstIndex] = (byte)(val >> 8);
    }

	if m >= scannerMetricLast {
		return 0
	}
	val := atomic.LoadUint64(&p.operations[m])
	return val
}

// lastMinute returns the last minute statistics of a metric.
// m should be < scannerMetricLastRealtime
func (p *scannerMetrics) lastMinute(m scannerMetric) AccElem {
	if m >= scannerMetricLastRealtime {
		return AccElem{}
	}
	val := p.latency[m].total()
	return val
}

      "xn--1ug.example",
      // OkHttp doesn't implement CheckJoiners.
      "\u200D.example",
      // OkHttp doesn't implement CheckBidi.
      "يa",
    )

  @Test
  fun test() {
    val list = WebPlatformToAsciiData.load()
    val failures = mutableListOf<Throwable>()
    for (entry in list) {
      var failure: Throwable? = null
      try {
        testToAscii(entry.input!!, entry.output, entry.comment)

import okio.ForwardingSink
import okio.Path
import okio.Sink

class FaultyFileSystem constructor(delegate: FileSystem?) : ForwardingFileSystem(delegate!!) {
  private val writeFaults: MutableSet<Path> = LinkedHashSet()
  private val deleteFaults: MutableSet<Path> = LinkedHashSet()
  private val renameFaults: MutableSet<Path> = LinkedHashSet()

  fun setFaultyWrite(
    file: Path,
    faulty: Boolean,
  ) {
    if (faulty) {

import org.gradle.api.reflect.TypeOf
import org.gradle.kotlin.dsl.*


internal
val CtClass.isKotlin: Boolean
    get() = hasAnnotation(Metadata::class.qualifiedName)


internal
val CtMethod.isSynthetic
    get() = methodInfo.getAttribute(SyntheticAttribute.tag) != null


internal
val MemberValue.intValue: Int
    get() {
        var value: Int? = null

import okio.source
import org.brotli.dec.BrotliInputStream

fun uncompress(response: Response): Response {
  if (!response.promisesBody()) {
    return response
  }
  val body = response.body
  val encoding = response.header("Content-Encoding") ?: return response

  val decompressedSource =
    when {
      encoding.equals("br", ignoreCase = true) ->
        BrotliInputStream(body.source().inputStream()).source().buffer()