private static final String NAME_PREFIX = "accessTokenTest_";
    private static final String API_PATH = "/api/admin/accesstoken";
    private static final String LIST_ENDPOINT_SUFFIX = "settings";
    private static final String ITEM_ENDPOINT_SUFFIX = "setting";

    private static final String KEY_PROPERTY = "name";

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

        this.value = value;
    }

    public String asString() {
        return value;
    }

    @Override
    public String toString() {
        return asString();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

// the DNS SANs.
func NewIstioConfig(systemNamespace string) (string, error) {
	return tmpl.Evaluate(istioConfTemplate, map[string]any{
		"SystemNamespace": systemNamespace,
	})
}

// IntermediateCA is an intermediate CA for a single cluster.
type Intermediate struct {
	KeyFile  string
	ConfFile string
	CSRFile  string
	CertFile string
	Root     Root
}

            else -> return nonLocalFqName.asString()
        }
        val container = (symbol as? KaSymbolWithKind)?.getContainingSymbol() ?: return null
        val parents = generateSequence(container) { it.getContainingSymbol() }.toList().asReversed()
        return "<local>: " + parents.joinToString(separator = ".") { (it as? KaNamedSymbol)?.name?.asString() ?: "<no name>" }
    }

            }

            is KaConstantAnnotationValue -> {
                printer.append(value.constantValue.constantValueKind.asString)
                    .append("(")
                    .append(value.constantValue.value.toString())
                    .append(")")
            }

            is KaUnsupportedAnnotationValue -> {

#include "_cgo_export.h"

static void clobber_stack() {
	volatile char a[1024];
	int i;
	for(i = 0; i < sizeof a; i++)
		a[i] = 0xff;
}

static int call_go() {
	GoString s;
	s.p = "test";
	s.n = 4;
	return issue5548FromC(s, 42);
}

int issue5548_in_c() {
	clobber_stack();
	return call_go();

            ConstantValueKind.String -> CompileTimeType.STRING

            else -> CompileTimeType.ANY
        }
    }

    // Unary operators
    private fun FirLiteralExpression.evaluate(function: FirSimpleFunction): FirLiteralExpression? {
        if (value == null) return null
        (value as? String)?.let { opr ->
            evalUnaryOp(

        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>asString</td>
            </tr>
            <tr>
                <td>asReader</td>
            </tr>
            <tr>
                <td>asFile</td>
            </tr>
        </table>
    </section>

(ArraySelect [i] x:(Load <t> ptr mem)) =>
  @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.Elem().Size()*i] ptr) mem)

(StringPtr x:(Load <t> ptr mem)) && t.IsString() => @x.Block (Load <typ.BytePtr> ptr mem)
(StringLen x:(Load <t> ptr mem)) && t.IsString() => @x.Block (Load <typ.Int>
      (OffPtr <typ.IntPtr> [config.PtrSize] ptr)
      mem)

// NOTE removed must-not-be-SSA condition.

	scope.Debugf("validatePortNumberString %v:", val)
	if !util.IsString(val) {
		return util.NewErrs(fmt.Errorf("validatePortNumberString(%s) bad type %T, want string", path, val))
	}
	if val.(string) == "*" || val.(string) == "" {
		return nil
	}
	intV, err := strconv.ParseInt(val.(string), 10, 32)
	if err != nil {
		return util.NewErrs(fmt.Errorf("%s : %s", path, err))
	}
	return validatePortNumber(path, intV)
}