import org.jetbrains.kotlin.utils.mapToSetOrEmpty
import kotlin.test.fail

abstract class AbstractSymbolTest : AbstractAnalysisApiBasedTest() {
    open val defaultRenderer = KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES

    open val defaultRendererOption: PrettyRendererOption? = null

    override fun configureTest(builder: TestConfigurationBuilder) {
        super.configureTest(builder)
        with(builder) {

 * the License.
 */

/**
 * Utility methods and classes for networking (such as IP addresses and domain names).
 *
 * <p>This package is a part of the open-source <a href="https://github.com/google/guava">Guava</a>
 * library.
 *
 * @author Craig Berry
 */
@CheckReturnValue
@ParametersAreNonnullByDefault
package com.google.common.net;

import org.jetbrains.kotlin.analysis.api.KaSession
import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeToken

public abstract class KaSessionComponent {
    protected abstract val analysisSession: KaSession
    protected open val token: KaLifetimeToken get() = analysisSession.token
}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "plugin"

func F() int {
	p2, err := plugin.Open("issue22175_plugin2.so")
	if err != nil {
		panic(err)
	}
	g, err := p2.Lookup("G")
	if err != nil {
		panic(err)
	}
	return g.(func() int)()
}

                          example: "Open Source Enterprise Search Server: Fess — Fess 11.0 documentation"
                        content_title:
                          type: string
                          example: "Open Source Enterprise Search Server: Fess — Fe..."
                        digest:
                          type: string

	untranslatedErr := errors.New("some random error")
	db, _ := gorm.Open(tests.DummyDialector{TranslatedErr: translatedErr})

	err := db.AddError(untranslatedErr)
	if !errors.Is(err, untranslatedErr) {
		t.Fatalf("expected err: %v got err: %v", untranslatedErr, err)
	}

	// it should translate error when the TranslateError flag is true
	db, _ = gorm.Open(tests.DummyDialector{TranslatedErr: translatedErr}, &gorm.Config{TranslateError: true})

		}
	})

	// Now test with a read PTY.
	t.Run("pty", func(t *testing.T) {
		r, processTTY, err := testpty.Open()
		if errors.Is(err, testpty.ErrNotSupported) {
			t.Skipf("%s", err)
		} else if err != nil {
			t.Fatalf("failed to open test PTY: %s", err)
		}
		defer r.Close()
		w, err := os.OpenFile(processTTY, os.O_RDWR, 0)
		if err != nil {
			t.Fatal(err)
		}
		defer w.Close()

        functionExtractor = CompositeFunctionExtractor(builder.functionExtractors),
        typeDiscovery = CompositeTypeDiscovery(builder.typeDiscoveries)
    )
    return analysisSchema
}


private
open class DefaultEvaluationSchemaBuilder : EvaluationSchemaBuilder {
    private
    val analysisSchemaComponents = mutableListOf<AnalysisSchemaComponent>()

    override val typeDiscoveries: List<TypeDiscovery>

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "plugin"

func main() {
	p, err := plugin.Open("plugin.so")
	if err != nil {
		panic(err)
	}

	sym, err := p.Lookup("G")
	if err != nil {
		panic(err)
	}
	g := sym.(func() bool)
	if !g() {
		panic("expected types to match, Issue #18584")
	}

        VALUE_PARAMETER name:p0 index:0 type:kotlin.String
        EXPRESSION_BODY
          BLOCK type=kotlin.Int origin=null
            CALL 'public open fun <get-length> (): kotlin.Int declared in kotlin.String' type=kotlin.Int origin=GET_PROPERTY