log.Fatal(err) // e.g. EMFILE
		}
		println("hello")
		panic("oops")
	}

	// default: run the tests.
	os.Exit(m.Run())
}

type T int

func (t *T) ptrmethod() []byte {
	return Stack()
}
func (t T) method() []byte {
	return t.ptrmethod()
}

/*
The traceback should look something like this, modulo line numbers and hex constants.
Don't worry much about the base levels, but check the ones in our own package.

        return acceptOrReject(c, changes, Violation.error(c, " methods removed in internal super class"))
    }

    private Set<CtMethod> collectAllPublicApiMethods(CtClass c) {
        Set<CtMethod> result = [] as Set
        collect(result, c)
        return result
    }

    private void collect(Set<CtMethod> result, CtClass c) {
        if (c == null) {
            return
        }

        else hasKotlinFlag(ctMember, Flag.IS_INTERNAL)

    fun isKotlinOperatorFunction(ctMethod: CtMethod): Boolean =
        hasKotlinFlag(ctMethod, Flag.Function.IS_OPERATOR)

    fun isKotlinInfixFunction(ctMethod: CtMethod): Boolean =
        hasKotlinFlag(ctMethod, Flag.Function.IS_INFIX)

    private
    fun hasKotlinFlag(ctClass: CtClass, flag: Flag): Boolean =

            append(psiElement.containingClass?.name)
            append(".")
            append(psiElement.name)
            append(": ")
            append(psiElement.type)
        }
        is PsiMethod -> buildString {
            append("PsiMethod:")
            append(psiElement.name)
            append("(")
            psiElement.parameterList.parameters.joinTo(this) { render(it) }
            append("): ")

        val putMethod = alpnClass.getMethod("put", SSLSocket::class.java, providerClass)
        val getMethod = alpnClass.getMethod("get", SSLSocket::class.java)
        val removeMethod = alpnClass.getMethod("remove", SSLSocket::class.java)
        return Jdk8WithJettyBootPlatform(
          putMethod,
          getMethod,
          removeMethod,
          clientProviderClass,

internal class JavaElementDelegatingMethodReturnTypeSourceWithSmartPointer<TYPE : PsiType>(
    override val psiPointer: SmartPsiElementPointer<out PsiMethod>,
    override val factory: JavaElementSourceFactory,
) : JavaElementDelegatingTypeSourceWithSmartPointer<PsiMethod, TYPE>() {

    override fun getType(psi: PsiMethod): TYPE {
        @Suppress("UNCHECKED_CAST")
        return psi.returnType as TYPE
    }
}

 */

package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.psiTypeProvider

import com.intellij.psi.PsiElement
import com.intellij.psi.PsiMethod
import com.intellij.psi.PsiType
import com.intellij.psi.PsiVariable
import org.jetbrains.kotlin.analysis.api.types.KaType
import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest

        } else if (member instanceof JApiMethod) {

            JApiMethod method = (JApiMethod) member
            CtMethod oldMethod = method.oldMethod.get()
            CtMethod newMethod = method.newMethod.get()

            inspectParametersNullabilityOf(oldMethod, newMethod)

            def oldNullability = hasNullableAnnotation(oldMethod)

 * limitations under the License.
 */

@file:JvmName("JavassistExtensions")

package gradlebuild.binarycompatibility

import javassist.CtClass
import javassist.CtMethod
import javassist.bytecode.SyntheticAttribute
import javassist.bytecode.annotation.AnnotationMemberValue
import javassist.bytecode.annotation.ArrayMemberValue
import javassist.bytecode.annotation.BooleanMemberValue

        this is ClsElementImpl && hasAnnotation(JvmAnnotationNames.METADATA_FQ_NAME.asString())

    override fun getCallableSymbol(callable: PsiMember): KaCallableSymbol? {
        if (callable !is PsiMethod && callable !is PsiField) return null
        val name = callable.name?.let(Name::identifier) ?: return null
        val containingClass = callable.containingClass ?: return null