// rel-ro sections using relROMap.
var ReadOnly = []SymKind{
	STYPE,
	SSTRING,
	SGOSTRING,
	SGOFUNC,
	SGCBITS,
	SRODATA,
	SFUNCTAB,
}

// RelROMap describes the transformation of read-only symbols to rel-ro
// symbols.
var RelROMap = map[SymKind]SymKind{
	STYPE:     STYPERELRO,
	SSTRING:   SSTRINGRELRO,
	SGOSTRING: SGOSTRINGRELRO,
	SGOFUNC:   SGOFUNCRELRO,

}

//sys	bind(name string, old string, flag int) (err error)

func Bind(name string, old string, flag int) (err error) {
	if fixwd(name, old) {
		defer runtime.UnlockOSThread()
	}
	return bind(name, old, flag)
}

//sys	mount(fd int, afd int, old string, flag int, aname string) (err error)

func Mount(fd int, afd int, old string, flag int, aname string) (err error) {
	if fixwd(old) {

            analysisSession: KaSession,
            name: Name,
            owner: KaType,
            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            printer.append(name.asString())
        }
    }
}

    }

    @Override
    public String asString() {
        String nodeString = super.asString();

        if (!verbose) {
            return nodeString;
        }

        org.eclipse.aether.graph.DependencyNode node = getDependencyNode();

        List<String> details = new ArrayList<>();

        org.eclipse.aether.graph.DependencyNode winner =

            connections[HttpConnection.currentConnection] = connectionAuth
        }

        if (connectionAuth.failed) {
            httpResponse.setHeader(HttpHeader.WWW_AUTHENTICATE.asString(), "basic realm=\"" + _loginService.getName() + '"')
            httpResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED)
            return Authentication.SEND_CONTINUE
        } else if (connectionAuth.user != null) {

                }?.fqNameForClassNameWithoutDollars?.asString()
            }
            else -> {
                return if (containingSymbolOrSelf.symbolKind == KaSymbolKind.TOP_LEVEL) {
                    descriptor?.let(DescriptorToSourceUtils::getContainingFile)
                        ?.takeUnless { it.isScript() }
                        ?.javaFileFacadeFqName?.asString()
                } else {

var _AlgKind_index = [...]uint8{0, 3, 7, 12, 15, 19, 23, 28, 33, 38, 44, 50, 55, 63, 70, 77, 83, 90, 97}

func (i AlgKind) String() string {
	if i < 0 || i >= AlgKind(len(_AlgKind_index)-1) {
		return "AlgKind(" + strconv.FormatInt(int64(i), 10) + ")"
	}
	return _AlgKind_name[_AlgKind_index[i]:_AlgKind_index[i+1]]

public class JobLogTests extends CrudTestBase {

    private static final String NAME_PREFIX = "joblogTest_";
    private static final String API_PATH = "/api/admin/joblog";
    private static final String LIST_ENDPOINT_SUFFIX = "logs";
    private static final String ITEM_ENDPOINT_SUFFIX = "log";

    private static final String KEY_PROPERTY = "";

    @Override
    protected String getNamePrefix() {
        return NAME_PREFIX;
    }

        return KaFirPsiJavaClassSymbol(psiClass, analysisSession)
    }

    private fun PsiClass.isKotlinCompiledClass() =
        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

        }
    }

    private fun render(symbol: KaSymbol): String {
        val qualifiedName = when (symbol) {
            is KaCallableSymbol -> symbol.callableId?.toString()
            is KaClassLikeSymbol -> symbol.classId?.toString()
            else -> null
        }

        return qualifiedName ?: (symbol as? KaNamedSymbol)?.name?.asString() ?: "Unnamed"
    }