)
    }

    private
    fun schemaWithExtensions(vararg pairs: Pair<String, SchemaType>) = projectSchemaWith(
        extensions = pairs.map { ProjectSchemaEntry(SchemaType.of<Project>(), it.first, it.second) }
    )

    private
    fun <T> ProjectSchema<T>.extension(name: String) =
        extensions.single { it.name == name }
}


internal
fun projectSchemaWith(

     */
    fun addInformationalResponse(response: MockResponse) =
      apply {
        informationalResponses += response
      }

    fun add100Continue() =
      apply {
        addInformationalResponse(MockResponse(code = 100))
      }

    public override fun clone(): Builder = build().newBuilder()

    fun build(): MockResponse = MockResponse(this)
  }

import org.junit.jupiter.api.Test

class CertificatePinnerTest {
  @Test
  fun malformedPin() {
    val builder = CertificatePinner.Builder()
    assertFailsWith<IllegalArgumentException> {
      builder.add("example.com", "md5/DmxUShsZuNiqPQsX2Oi9uv2sCnw=")
    }
  }

  @Test
  fun malformedBase64() {
    val builder = CertificatePinner.Builder()
    assertFailsWith<IllegalArgumentException> {

    abstract fun KaSession.getScope(symbol: KaSymbolWithMembers): KaScope

    final override fun KaSession.getScope(mainFile: KtFile, testServices: TestServices): KaScope =
        getScope(getSingleTestTargetSymbolOfType<KaSymbolWithMembers>(mainFile, testDataPath))
}

abstract class AbstractMemberScopeTest : AbstractMemberScopeTestBase() {

            CONST String type=kotlin.String value="!"
    FUN name:show visibility:public modality:FINAL <> (str:kotlin.String) returnType:kotlin.Unit
      VALUE_PARAMETER name:str index:0 type:kotlin.String
      BLOCK_BODY
    FUN name:test visibility:public modality:FINAL <> () returnType:kotlin.Int
      BLOCK_BODY
        RETURN type=kotlin.Nothing from='public final fun test (): kotlin.Int declared in <root>'

 */
class FixedValueReplacingProviderCodec(

    private
    val providerWithChangingValueCodec: Codec<Any?>

) {
    suspend fun WriteContext.encodeProvider(value: ProviderInternal<*>) {
        val state = value.calculateExecutionTimeValue()
        encodeValue(state)
    }

    suspend fun WriteContext.encodeValue(value: ValueSupplier.ExecutionTimeValue<*>) {
        val sideEffect = value.sideEffect
        when {

        }

    private
    fun readerContextFor(
        inputStream: InputStream,
    ) = readerContextFor(KryoBackedDecoder(inputStream))

    internal
    fun readerContextFor(
        decoder: Decoder,
    ) =
        readContextFor(decoder, codecs).apply {
            initClassLoader(javaClass.classLoader)
        } to codecs

    private
    fun writeContextFor(
        encoder: Encoder,

		isInstance = true
		fun, _, _, _ = typeparams.UnpackIndexExpr(fun)
	}

	var obj types.Object
	switch fun := fun.(type) {
	case *ast.Ident:
		obj = info.Uses[fun] // type, var, builtin, or declared func
	case *ast.SelectorExpr:
		if sel, ok := info.Selections[fun]; ok {
			obj = sel.Obj() // method or field
		} else {
			obj = info.Uses[fun.Sel] // qualified identifier?
		}
	}

        get() = KaFe10PackageSymbol(FqName.ROOT, analysisContext)

    override fun getFileSymbol(psi: KtFile): KaFileSymbol {
        return KaFe10FileSymbol(psi, analysisContext)
    }

    override fun getScriptSymbol(psi: KtScript): KaScriptSymbol {
        return KaFe10PsiScriptSymbol(psi, analysisContext)
    }

    override fun getParameterSymbol(psi: KtParameter): KaVariableLikeSymbol {
        return when {

            packageFqName = packageOrClass.packageFqName
        }
    }

    fun getRegularClass(type: ConeKotlinType?): FirRegularClass? {
        return type?.toRegularClassSymbol(firSession)?.fir
    }

    fun toClassSymbol(classId: ClassId) =
        firSession.symbolProvider.getClassLikeSymbolByClassId(classId)

    fun convertToImportableName(callableSymbol: FirCallableSymbol<*>): FqName? =