override val typesCreatorImpl: KtTypeCreator = KtFe10TypeCreator(this)
    override val samResolverImpl: KtSamResolver = KtFe10SamResolver(this)
    override val importOptimizerImpl: KtImportOptimizer = KtFe10ImportOptimizer(this)
    override val jvmTypeMapperImpl: KtJvmTypeMapper = KtFe10JvmTypeMapper(this)
    override val symbolInfoProviderImpl: KtSymbolInfoProvider = KtFe10SymbolInfoProvider(this)

  fun equalsFromTrustManager() {
    val handshakeCertificates = HandshakeCertificates.Builder().build()
    val x509TrustManager = handshakeCertificates.trustManager
    assertThat(get(x509TrustManager)).isEqualTo(get(x509TrustManager))
  }

  @Test
  fun normalizeSingleSelfSignedCertificate() {
    val root =
      HeldCertificate.Builder()
        .serialNumber(1L)
        .build()
    val cleaner = get(root.certificate)

internal class KtFe10DescKotlinPropertySymbol(
    override val descriptor: PropertyDescriptorImpl,
    override val analysisContext: Fe10AnalysisContext
) : KtKotlinPropertySymbol(), KtFe10DescMemberSymbol<PropertyDescriptorImpl> {
    override val name: Name
        get() = withValidityAssertion { descriptor.name }

    override val symbolKind: KtSymbolKind
        get() = withValidityAssertion {

    class DefaultKtValueParameterSymbol(
        private val propertyPsi: KtProperty,
        val descriptor: ValueParameterDescriptor?,
        override val analysisContext: Fe10AnalysisContext
    ) : KtValueParameterSymbol(), KtFe10Symbol {
        override val hasDefaultValue: Boolean
            get() = withValidityAssertion { false }

        override val isVararg: Boolean
            get() = withValidityAssertion { false }

    override val DOUBLE: KtType by cachedBuiltin(builtinTypes.doubleType)

    override val CHAR: KtType by cachedBuiltin(builtinTypes.charType)
    override val BOOLEAN: KtType by cachedBuiltin(builtinTypes.booleanType)
    override val STRING: KtType by cachedBuiltin(builtinTypes.stringType)

    override val UNIT: KtType by cachedBuiltin(builtinTypes.unitType)

class Jdk8WithJettyBootPlatform(
  private val putMethod: Method,
  private val getMethod: Method,
  private val removeMethod: Method,
  private val clientProviderClass: Class<*>,
  private val serverProviderClass: Class<*>,
) : Platform() {
  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {
    val names = alpnProtocolNames(protocols)

    try {

      ).encodeUtf8(),
    )
  }

  @Test
  fun multipleOperatorsShareOneFile() {
    val operatorA =
      FileOperator(
        randomAccessFile!!.getChannel(),
      )
    val operatorB =
      FileOperator(
        randomAccessFile!!.getChannel(),
      )
    val bufferA = Buffer()
    val bufferB = Buffer()
    bufferA.writeUtf8("Dodgson!\n")
    operatorA.write(0, bufferA, 9)

    }
    val jvm = org.gradle.internal.jvm.Jvm.current()
    val javaVersion = JavaVersion.current()
    val isWindows = OperatingSystem.current().isWindows
    val isLinux = OperatingSystem.current().isLinux
    val isMacOsX = OperatingSystem.current().isMacOsX
    val isIntel: Boolean = architecture == "x86_64" || architecture == "x86"
    val isSlowInternetConnection

data class HLDiagnostic(
    val original: DiagnosticData,
    val severity: Severity?,
    val className: String,
    val implClassName: String,
    val parameters: List<HLDiagnosticParameter>,
)

data class HLDiagnosticList(val diagnostics: List<HLDiagnostic>)

data class HLDiagnosticParameter(
    val original: DiagnosticParameter,
    val name: String,
    val type: KType,
    val originalParameterName: String,

internal class KtFe10PsiPropertySetterSymbol(
    override val psi: KtPropertyAccessor,
    override val analysisContext: Fe10AnalysisContext
) : KtPropertySetterSymbol(), KtFe10PsiSymbol<KtPropertyAccessor, PropertySetterDescriptor> {
    override val descriptor: PropertySetterDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)